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 BUILD_ICECC
 636 ICECC
 637 ICECC_WRAPPER
 638 ICECC_CREATE_ENV
 639 ICECC_CMD
 640 ENABLE_JAVAC_SERVER
 641 ENABLE_SJAVAC
 642 SJAVAC_SERVER_JAVA_FLAGS
 643 SJAVAC_SERVER_JAVA
 644 JAVA_TOOL_FLAGS_SMALL
 645 JAVA_FLAGS_SMALL
 646 JAVA_FLAGS_JAVAC
 647 JAVA_FLAGS_BIG
 648 JAVA_FLAGS
 649 JOBS
 650 MEMORY_SIZE
 651 NUM_CORES
 652 ENABLE_INTREE_EC
 653 SALIB_NAME
 654 HOTSPOT_MAKE_ARGS
 655 LIBZIP_CAN_USE_MMAP
 656 LIBDL
 657 LIBM
 658 USE_EXTERNAL_LCMS
 659 LCMS_LIBS
 660 LCMS_CFLAGS
 661 USE_EXTERNAL_LIBZ
 662 USE_EXTERNAL_LIBPNG
 663 PNG_LIBS
 664 PNG_CFLAGS
 665 USE_EXTERNAL_LIBGIF
 666 USE_EXTERNAL_LIBJPEG
 667 LLVM_LIBS
 668 LLVM_LDFLAGS
 669 LLVM_CFLAGS
 670 LLVM_CONFIG
 671 LIBFFI_LIBS
 672 LIBFFI_CFLAGS
 673 ALSA_LIBS
 674 ALSA_CFLAGS
 675 FREETYPE_BUNDLE_LIB_PATH
 676 FREETYPE_LIBS
 677 FREETYPE_CFLAGS
 678 CUPS_CFLAGS
 679 X_EXTRA_LIBS
 680 X_LIBS
 681 X_PRE_LIBS
 682 X_CFLAGS
 683 XMKMF
 684 MSVCP_DLL
 685 MSVCR_DLL
 686 LIBCXX
 687 STATIC_CXX_SETTING
 688 FIXPATH_DETACH_FLAG
 689 FIXPATH
 690 GCOV_ENABLED

 691 ZIP_DEBUGINFO_FILES
 692 ENABLE_DEBUG_SYMBOLS



 693 CFLAGS_WARNINGS_ARE_ERRORS
 694 DISABLE_WARNING_PREFIX
 695 HOTSPOT_SET_WARNINGS_AS_ERRORS
 696 WARNINGS_AS_ERRORS
 697 COMPILER_SUPPORTS_TARGET_BITS_FLAG
 698 ZERO_ARCHFLAG
 699 LDFLAGS_TESTEXE
 700 LDFLAGS_TESTLIB
 701 LDFLAGS_CXX_JDK
 702 JDKEXE_LIBS
 703 JDKLIB_LIBS
 704 LDFLAGS_JDKEXE
 705 LDFLAGS_JDKLIB
 706 CXXFLAGS_TESTEXE
 707 CXXFLAGS_TESTLIB
 708 CFLAGS_TESTEXE
 709 CFLAGS_TESTLIB
 710 CXXFLAGS_JDKEXE
 711 CXXFLAGS_JDKLIB
 712 CFLAGS_JDKEXE
 713 CFLAGS_JDKLIB
 714 MACOSX_VERSION_MIN
 715 CXX_O_FLAG_NONE
 716 CXX_O_FLAG_DEBUG
 717 CXX_O_FLAG_NORM
 718 CXX_O_FLAG_HI
 719 CXX_O_FLAG_HIGHEST
 720 C_O_FLAG_NONE
 721 C_O_FLAG_DEBUG
 722 C_O_FLAG_NORM
 723 C_O_FLAG_HI
 724 C_O_FLAG_HIGHEST
 725 CXXFLAGS_DEBUG_SYMBOLS
 726 CFLAGS_DEBUG_SYMBOLS
 727 CXX_FLAG_DEPS
 728 C_FLAG_DEPS
 729 SET_SHARED_LIBRARY_MAPFILE
 730 SET_SHARED_LIBRARY_NAME
 731 SET_SHARED_LIBRARY_ORIGIN
 732 SET_EXECUTABLE_ORIGIN
 733 CXX_FLAG_REORDER
 734 C_FLAG_REORDER
 735 RC_FLAGS
 736 AR_OUT_OPTION
 737 LD_OUT_OPTION
 738 EXE_OUT_OPTION
 739 CC_OUT_OPTION
 740 STRIPFLAGS
 741 ARFLAGS
 742 COMPILER_TARGET_BITS_FLAG
 743 JT_HOME
 744 JTREGEXE
 745 USING_BROKEN_SUSE_LD
 746 PACKAGE_PATH
 747 USE_CLANG
 748 HOTSPOT_LD
 749 HOTSPOT_CXX
 750 HOTSPOT_RC
 751 HOTSPOT_MT
 752 BUILD_AS
 753 BUILD_LD
 754 BUILD_AR
 755 BUILD_NM
 756 BUILD_CXX
 757 BUILD_CC
 758 BUILD_SYSROOT_LDFLAGS
 759 BUILD_SYSROOT_CFLAGS
 760 ac_ct_OBJDUMP
 761 OBJDUMP
 762 ac_ct_OBJCOPY
 763 OBJCOPY
 764 ac_ct_NM
 765 ac_ct_STRIP
 766 GNM
 767 NM
 768 STRIP
 769 MSBUILD
 770 DUMPBIN
 771 RC
 772 MT
 773 LIPO
 774 ac_ct_AR
 775 AR
 776 AS
 777 LDCXX
 778 LD
 779 CXXCPP
 780 CPP
 781 ac_ct_CXX
 782 CXXFLAGS
 783 CXX
 784 ac_ct_PROPER_COMPILER_CXX
 785 PROPER_COMPILER_CXX
 786 TOOLCHAIN_PATH_CXX
 787 POTENTIAL_CXX
 788 OBJEXT
 789 EXEEXT
 790 ac_ct_CC
 791 CPPFLAGS
 792 LDFLAGS
 793 CFLAGS
 794 CC
 795 ac_ct_PROPER_COMPILER_CC
 796 PROPER_COMPILER_CC
 797 TOOLCHAIN_PATH_CC
 798 POTENTIAL_CC
 799 VS_LIB
 800 VS_INCLUDE
 801 VS_PATH
 802 CYGWIN_LINK
 803 SYSROOT_LDFLAGS
 804 SYSROOT_CFLAGS
 805 LEGACY_EXTRA_LDFLAGS
 806 LEGACY_EXTRA_CXXFLAGS
 807 LEGACY_EXTRA_CFLAGS
 808 EXE_SUFFIX
 809 OBJ_SUFFIX
 810 STATIC_LIBRARY
 811 SHARED_LIBRARY
 812 STATIC_LIBRARY_SUFFIX
 813 SHARED_LIBRARY_SUFFIX
 814 LIBRARY_PREFIX
 815 TOOLCHAIN_TYPE
 816 STATIC_BUILD
 817 BUILD_HOTSPOT
 818 HOTSPOT_DIST
 819 BUILD_OUTPUT
 820 JDK_TOPDIR
 821 NASHORN_TOPDIR
 822 HOTSPOT_TOPDIR
 823 JAXWS_TOPDIR
 824 JAXP_TOPDIR
 825 CORBA_TOPDIR
 826 LANGTOOLS_TOPDIR
 827 BOOT_JDK_BITS
 828 JAVAC_FLAGS
 829 BOOT_JDK_SOURCETARGET
 830 JARSIGNER
 831 JAR
 832 JAVAH
 833 JAVAC
 834 JAVA
 835 BOOT_JDK
 836 JAVA_CHECK
 837 JAVAC_CHECK
 838 COOKED_BUILD_NUMBER
 839 JDK_VERSION
 840 COPYRIGHT_YEAR
 841 MACOSX_BUNDLE_ID_BASE
 842 MACOSX_BUNDLE_NAME_BASE
 843 COMPANY_NAME
 844 JDK_RC_PLATFORM_NAME
 845 PRODUCT_SUFFIX
 846 PRODUCT_NAME
 847 LAUNCHER_NAME
 848 MILESTONE
 849 JDK_BUILD_NUMBER
 850 JDK_UPDATE_VERSION
 851 JDK_MICRO_VERSION
 852 JDK_MINOR_VERSION
 853 JDK_MAJOR_VERSION
 854 USER_RELEASE_SUFFIX
 855 COMPRESS_JARS
 856 UNLIMITED_CRYPTO
 857 CACERTS_FILE
 858 TEST_IN_BUILD
 859 BUILD_HEADLESS
 860 SUPPORT_HEADFUL
 861 SUPPORT_HEADLESS
 862 OS_VERSION_MICRO
 863 OS_VERSION_MINOR
 864 OS_VERSION_MAJOR
 865 PKG_CONFIG
 866 BASH_ARGS
 867 SETFILE
 868 CODESIGN
 869 XATTR
 870 DSYMUTIL
 871 IS_GNU_TIME
 872 PATCH
 873 TIME
 874 STAT
 875 HG
 876 READELF
 877 OTOOL
 878 LDD
 879 ZIP
 880 UNZIP
 881 FIND_DELETE
 882 OUTPUT_SYNC
 883 OUTPUT_SYNC_SUPPORTED
 884 CHECK_TOOLSDIR_MAKE
 885 CHECK_TOOLSDIR_GMAKE
 886 CHECK_MAKE
 887 CHECK_GMAKE
 888 MAKE
 889 PKGHANDLER
 890 CONFIGURESUPPORT_OUTPUTDIR
 891 OUTPUT_ROOT
 892 CONF_NAME
 893 SPEC
 894 SDKROOT
 895 XCODEBUILD
 896 BUILD_VARIANT_RELEASE
 897 DEBUG_CLASSFILES
 898 FASTDEBUG
 899 VARIANT
 900 DEBUG_LEVEL
 901 MACOSX_UNIVERSAL
 902 INCLUDE_SA
 903 JVM_VARIANT_CORE
 904 JVM_VARIANT_ZEROSHARK
 905 JVM_VARIANT_ZERO
 906 JVM_VARIANT_KERNEL
 907 JVM_VARIANT_MINIMAL1
 908 JVM_VARIANT_CLIENT
 909 JVM_VARIANT_SERVER
 910 JVM_VARIANTS
 911 JVM_INTERPRETER
 912 JDK_VARIANT
 913 SET_OPENJDK
 914 CANONICAL_TOPDIR
 915 ORIGINAL_TOPDIR
 916 TOPDIR
 917 PATH_SEP
 918 ZERO_ARCHDEF
 919 DEFINE_CROSS_COMPILE_ARCH
 920 LP64
 921 OPENJDK_TARGET_OS_EXPORT_DIR
 922 OPENJDK_TARGET_CPU_JLI_CFLAGS
 923 OPENJDK_TARGET_CPU_OSARCH
 924 OPENJDK_TARGET_CPU_ISADIR
 925 OPENJDK_TARGET_CPU_LIBDIR
 926 OPENJDK_TARGET_CPU_LEGACY_LIB
 927 OPENJDK_TARGET_CPU_LEGACY
 928 REQUIRED_OS_VERSION
 929 REQUIRED_OS_NAME
 930 COMPILE_TYPE
 931 OPENJDK_TARGET_CPU_ENDIAN
 932 OPENJDK_TARGET_CPU_BITS
 933 OPENJDK_TARGET_CPU_ARCH
 934 OPENJDK_TARGET_CPU
 935 OPENJDK_TARGET_OS_ENV
 936 OPENJDK_TARGET_OS_TYPE
 937 OPENJDK_TARGET_OS
 938 OPENJDK_BUILD_CPU_ENDIAN
 939 OPENJDK_BUILD_CPU_BITS
 940 OPENJDK_BUILD_CPU_ARCH
 941 OPENJDK_BUILD_CPU
 942 OPENJDK_BUILD_OS_ENV
 943 OPENJDK_BUILD_OS_TYPE
 944 OPENJDK_BUILD_OS
 945 OPENJDK_BUILD_AUTOCONF_NAME
 946 OPENJDK_TARGET_AUTOCONF_NAME
 947 target_os
 948 target_vendor
 949 target_cpu
 950 target
 951 host_os
 952 host_vendor
 953 host_cpu
 954 host
 955 build_os
 956 build_vendor
 957 build_cpu
 958 build
 959 NICE
 960 CPIO
 961 DF
 962 READLINK
 963 CYGPATH
 964 SED
 965 FGREP
 966 EGREP
 967 GREP
 968 AWK
 969 XARGS
 970 WHICH
 971 WC
 972 UNIQ
 973 UNAME
 974 TR
 975 TOUCH
 976 TEE
 977 TAR
 978 TAIL
 979 SORT
 980 SH
 981 RMDIR
 982 RM
 983 PRINTF
 984 NAWK
 985 MV
 986 MKTEMP
 987 MKDIR
 988 LS
 989 LN
 990 HEAD
 991 FIND
 992 FILE
 993 EXPR
 994 ECHO
 995 DIRNAME
 996 DIFF
 997 DATE
 998 CUT
 999 CP
1000 COMM
1001 CMP
1002 CHMOD
1003 CAT
1004 BASH
1005 BASENAME
1006 DATE_WHEN_CONFIGURED
1007 ORIGINAL_PATH
1008 CONFIGURE_COMMAND_LINE
1009 target_alias
1010 host_alias
1011 build_alias
1012 LIBS
1013 ECHO_T
1014 ECHO_N
1015 ECHO_C
1016 DEFS
1017 mandir
1018 localedir
1019 libdir
1020 psdir
1021 pdfdir
1022 dvidir
1023 htmldir
1024 infodir
1025 docdir
1026 oldincludedir
1027 includedir
1028 localstatedir
1029 sharedstatedir
1030 sysconfdir
1031 datadir
1032 datarootdir
1033 libexecdir
1034 sbindir
1035 bindir
1036 program_transform_name
1037 prefix
1038 exec_prefix
1039 PACKAGE_URL
1040 PACKAGE_BUGREPORT
1041 PACKAGE_STRING
1042 PACKAGE_VERSION
1043 PACKAGE_TARNAME
1044 PACKAGE_NAME
1045 PATH_SEPARATOR
1046 SHELL'
1047 ac_subst_files=''
1048 ac_user_opts='
1049 enable_option_checking
1050 with_target_bits
1051 enable_openjdk_only
1052 with_custom_make_dir
1053 with_jdk_variant
1054 with_jvm_interpreter
1055 with_jvm_variants
1056 enable_debug
1057 with_debug_level
1058 with_devkit
1059 with_sys_root
1060 with_sysroot
1061 with_tools_dir
1062 with_toolchain_path
1063 with_extra_path
1064 with_sdk_name
1065 with_conf_name
1066 with_output_sync
1067 enable_headful
1068 enable_hotspot_test_in_build
1069 with_cacerts_file
1070 enable_unlimited_crypto
1071 with_milestone
1072 with_update_version
1073 with_user_release_suffix
1074 with_build_number
1075 with_copyright_year
1076 with_boot_jdk
1077 with_add_source_root
1078 with_override_source_root
1079 with_adds_and_overrides
1080 with_override_langtools
1081 with_override_corba
1082 with_override_jaxp
1083 with_override_jaxws
1084 with_override_hotspot
1085 with_override_nashorn
1086 with_override_jdk
1087 with_import_hotspot
1088 enable_static_build
1089 with_toolchain_type
1090 with_extra_cflags
1091 with_extra_cxxflags
1092 with_extra_ldflags
1093 with_toolchain_version
1094 with_build_devkit
1095 with_jtreg
1096 enable_warnings_as_errors


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




1880   --enable-native-coverage
1881                           enable native compilation with code coverage
1882                           data[disabled]
1883   --disable-freetype-bundling
1884                           disable bundling of the freetype library with the
1885                           build result [enabled on Windows or when using
1886                           --with-freetype, disabled otherwise]
1887   --enable-sjavac         use sjavac to do fast incremental compiles
1888                           [disabled]
1889   --disable-javac-server  disable javac server [enabled]
1890   --enable-icecc          enable distribted compilation of native code using
1891                           icecc/icecream [disabled]
1892   --disable-precompiled-headers
1893                           disable using precompiled headers when compiling C++
1894                           [enabled]
1895   --enable-ccache         enable using ccache to speed up recompilations
1896                           [disabled]
1897 
1898 Optional Packages:
1899   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
1900   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
1901   --with-target-bits      build 32-bit or 64-bit binaries (for platforms that
1902                           support it), e.g. --with-target-bits=32 [guessed]
1903   --with-custom-make-dir  Deprecated. Option is kept for backwards
1904                           compatibility and is ignored
1905   --with-jdk-variant      JDK variant to build (normal) [normal]
1906   --with-jvm-interpreter  JVM interpreter to build (template, cpp) [template]
1907   --with-jvm-variants     JVM variants (separated by commas) to build (server,
1908                           client, minimal1, kernel, zero, zeroshark, core)
1909                           [server]
1910   --with-debug-level      set the debug level (release, fastdebug, slowdebug,
1911                           optimized (HotSpot build only)) [release]
1912   --with-devkit           use this devkit for compilers, tools and resources
1913   --with-sys-root         alias for --with-sysroot for backwards compatability
1914   --with-sysroot          use this directory as sysroot
1915   --with-tools-dir        alias for --with-toolchain-path for backwards
1916                           compatibility
1917   --with-toolchain-path   prepend these directories when searching for
1918                           toolchain binaries (compilers etc)
1919   --with-extra-path       prepend these directories to the default path
1920   --with-sdk-name         use the platform SDK of the given name. [macosx]
1921   --with-conf-name        use this as the name of the configuration [generated
1922                           from important configuration options]
1923   --with-output-sync      set make output sync type if supported by make.
1924                           [recurse]
1925   --with-cacerts-file     specify alternative cacerts file
1926   --with-milestone        Set milestone value for build [internal]
1927   --with-update-version   Set update version value for build [b00]
1928   --with-user-release-suffix
1929                           Add a custom string to the version string if build
1930                           number is not set.[username_builddateb00]
1931   --with-build-number     Set build number value for build [b00]
1932   --with-copyright-year   Set copyright year value for build [current year]
1933   --with-boot-jdk         path to Boot JDK (used to bootstrap build) [probed]
1934   --with-add-source-root  Deprecated. Option is kept for backwards
1935                           compatibility and is ignored
1936   --with-override-source-root
1937                           Deprecated. Option is kept for backwards
1938                           compatibility and is ignored
1939   --with-adds-and-overrides
1940                           Deprecated. Option is kept for backwards
1941                           compatibility and is ignored
1942   --with-override-langtools
1943                           Deprecated. Option is kept for backwards
1944                           compatibility and is ignored
1945   --with-override-corba   Deprecated. Option is kept for backwards
1946                           compatibility and is ignored
1947   --with-override-jaxp    Deprecated. Option is kept for backwards
1948                           compatibility and is ignored
1949   --with-override-jaxws   Deprecated. Option is kept for backwards
1950                           compatibility and is ignored
1951   --with-override-hotspot Deprecated. Option is kept for backwards
1952                           compatibility and is ignored
1953   --with-override-nashorn Deprecated. Option is kept for backwards
1954                           compatibility and is ignored
1955   --with-override-jdk     Deprecated. Option is kept for backwards
1956                           compatibility and is ignored
1957   --with-import-hotspot   import hotspot binaries from this jdk image or
1958                           hotspot build dist dir instead of building from
1959                           source
1960   --with-toolchain-type   the toolchain type (or family) to use, use '--help'
1961                           to show possible values [platform dependent]
1962   --with-extra-cflags     extra flags to be used when compiling jdk c-files
1963   --with-extra-cxxflags   extra flags to be used when compiling jdk c++-files
1964   --with-extra-ldflags    extra flags to be used when linking jdk
1965   --with-toolchain-version
1966                           the version of the toolchain to look for, use
1967                           '--help' to show possible values [platform
1968                           dependent]
1969   --with-build-devkit     Devkit to use for the build platform toolchain
1970   --with-jtreg            Regression Test Harness [probed]



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-x                use the X Window System
1980   --with-cups             specify prefix directory for the cups package
1981                           (expecting the headers under PATH/include)
1982   --with-cups-include     specify directory for the cups include files
1983   --with-freetype         specify prefix directory for the freetype package
1984                           (expecting the libraries under PATH/lib and the
1985                           headers under PATH/include)
1986   --with-freetype-include specify directory for the freetype include files
1987   --with-freetype-lib     specify directory for the freetype library
1988   --with-freetype-src     specify directory with freetype sources to
1989                           automatically build the library (experimental,
1990                           Windows-only)
1991   --with-alsa             specify prefix directory for the alsa package
1992                           (expecting the libraries under PATH/lib and the
1993                           headers under PATH/include)
1994   --with-alsa-include     specify directory for the alsa include files
1995   --with-alsa-lib         specify directory for the alsa library
1996   --with-libffi           specify prefix directory for the libffi package
1997                           (expecting the libraries under PATH/lib and the
1998                           headers under PATH/include)
1999   --with-libffi-include   specify directory for the libffi include files
2000   --with-libffi-lib       specify directory for the libffi library
2001   --with-libjpeg          use libjpeg from build system or OpenJDK source
2002                           (system, bundled) [bundled]
2003   --with-giflib           use giflib from build system or OpenJDK source
2004                           (system, bundled) [bundled]
2005   --with-libpng           use libpng from build system or OpenJDK source
2006                           (system, bundled) [bundled]
2007   --with-zlib             use zlib from build system or OpenJDK source
2008                           (system, bundled) [bundled]
2009   --with-lcms             use lcms2 from build system or OpenJDK source
2010                           (system, bundled) [bundled]
2011   --with-dxsdk            Deprecated. Option is kept for backwards
2012                           compatibility and is ignored
2013   --with-dxsdk-lib        Deprecated. Option is kept for backwards
2014                           compatibility and is ignored
2015   --with-dxsdk-include    Deprecated. Option is kept for backwards
2016                           compatibility and is ignored
2017   --with-num-cores        number of cores in the build system, e.g.
2018                           --with-num-cores=8 [probed]
2019   --with-memory-size      memory (in MB) available in the build system, e.g.
2020                           --with-memory-size=1024 [probed]
2021   --with-jobs             number of parallel jobs to let make run [calculated
2022                           based on cores and memory]
2023   --with-boot-jdk-jvmargs specify JVM arguments to be passed to all java
2024                           invocations of boot JDK, overriding the default
2025                           values, e.g --with-boot-jdk-jvmargs="-Xmx8G
2026                           -enableassertions"
2027   --with-sjavac-server-java
2028                           use this java binary for running the sjavac
2029                           background server [Boot JDK java]
2030   --with-ccache-dir       where to store ccache files [~/.ccache]
2031 
2032 Some influential environment variables:
2033   BASENAME    Override default value for BASENAME
2034   BASH        Override default value for BASH
2035   CAT         Override default value for CAT
2036   CHMOD       Override default value for CHMOD
2037   CMP         Override default value for CMP
2038   COMM        Override default value for COMM
2039   CP          Override default value for CP
2040   CUT         Override default value for CUT
2041   DATE        Override default value for DATE
2042   DIFF        Override default value for DIFF
2043   DIRNAME     Override default value for DIRNAME
2044   ECHO        Override default value for ECHO
2045   EXPR        Override default value for EXPR
2046   FILE        Override default value for FILE
2047   FIND        Override default value for FIND
2048   HEAD        Override default value for HEAD
2049   LN          Override default value for LN
2050   LS          Override default value for LS
2051   MKDIR       Override default value for MKDIR
2052   MKTEMP      Override default value for MKTEMP
2053   MV          Override default value for MV
2054   NAWK        Override default value for NAWK
2055   PRINTF      Override default value for PRINTF
2056   RM          Override default value for RM
2057   RMDIR       Override default value for RMDIR
2058   SH          Override default value for SH
2059   SORT        Override default value for SORT
2060   TAIL        Override default value for TAIL
2061   TAR         Override default value for TAR
2062   TEE         Override default value for TEE
2063   TOUCH       Override default value for TOUCH
2064   TR          Override default value for TR
2065   UNAME       Override default value for UNAME
2066   UNIQ        Override default value for UNIQ
2067   WC          Override default value for WC
2068   WHICH       Override default value for WHICH
2069   XARGS       Override default value for XARGS
2070   AWK         Override default value for AWK
2071   GREP        Override default value for GREP
2072   EGREP       Override default value for EGREP
2073   FGREP       Override default value for FGREP
2074   SED         Override default value for SED
2075   CYGPATH     Override default value for CYGPATH
2076   READLINK    Override default value for READLINK
2077   DF          Override default value for DF
2078   CPIO        Override default value for CPIO
2079   NICE        Override default value for NICE
2080   MAKE        Override default value for MAKE
2081   UNZIP       Override default value for UNZIP
2082   ZIP         Override default value for ZIP
2083   LDD         Override default value for LDD
2084   OTOOL       Override default value for OTOOL
2085   READELF     Override default value for READELF
2086   HG          Override default value for HG
2087   STAT        Override default value for STAT
2088   TIME        Override default value for TIME
2089   PATCH       Override default value for PATCH
2090   DSYMUTIL    Override default value for DSYMUTIL
2091   XATTR       Override default value for XATTR
2092   CODESIGN    Override default value for CODESIGN
2093   SETFILE     Override default value for SETFILE
2094   PKG_CONFIG  path to pkg-config utility
2095   JAVA        Override default value for JAVA
2096   JAVAC       Override default value for JAVAC
2097   JAVAH       Override default value for JAVAH
2098   JAR         Override default value for JAR
2099   JARSIGNER   Override default value for JARSIGNER
2100   CC          C compiler command
2101   CFLAGS      C compiler flags
2102   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
2103               nonstandard directory <lib dir>
2104   LIBS        libraries to pass to the linker, e.g. -l<library>
2105   CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
2106               you have headers in a nonstandard directory <include dir>
2107   CXX         C++ compiler command
2108   CXXFLAGS    C++ compiler flags
2109   CPP         C preprocessor
2110   CXXCPP      C++ preprocessor
2111   AS          Override default value for AS
2112   AR          Override default value for AR
2113   LIPO        Override default value for LIPO
2114   STRIP       Override default value for STRIP
2115   NM          Override default value for NM
2116   GNM         Override default value for GNM
2117   OBJCOPY     Override default value for OBJCOPY
2118   OBJDUMP     Override default value for OBJDUMP
2119   BUILD_CC    Override default value for BUILD_CC
2120   BUILD_CXX   Override default value for BUILD_CXX
2121   BUILD_NM    Override default value for BUILD_NM
2122   BUILD_AR    Override default value for BUILD_AR
2123   JTREGEXE    Override default value for JTREGEXE
2124   XMKMF       Path to xmkmf, Makefile generator for X Window System
2125   FREETYPE_CFLAGS
2126               C compiler flags for FREETYPE, overriding pkg-config
2127   FREETYPE_LIBS
2128               linker flags for FREETYPE, overriding pkg-config
2129   ALSA_CFLAGS C compiler flags for ALSA, overriding pkg-config
2130   ALSA_LIBS   linker flags for ALSA, overriding pkg-config
2131   LIBFFI_CFLAGS
2132               C compiler flags for LIBFFI, overriding pkg-config
2133   LIBFFI_LIBS linker flags for LIBFFI, overriding pkg-config
2134   PNG_CFLAGS  C compiler flags for PNG, overriding pkg-config
2135   PNG_LIBS    linker flags for PNG, overriding pkg-config
2136   LCMS_CFLAGS C compiler flags for LCMS, overriding pkg-config
2137   LCMS_LIBS   linker flags for LCMS, overriding pkg-config
2138   ICECC_CMD   Override default value for ICECC_CMD
2139   ICECC_CREATE_ENV
2140               Override default value for ICECC_CREATE_ENV
2141   ICECC_WRAPPER
2142               Override default value for ICECC_WRAPPER
2143   CCACHE      Override default value for CCACHE
2144 
2145 Use these variables to override the choices made by `configure' or to help
2146 it to find libraries and programs with nonstandard names/locations.
2147 
2148 Report bugs to <build-dev@openjdk.java.net>.
2149 OpenJDK home page: <http://openjdk.java.net>.
2150 _ACEOF
2151 ac_status=$?
2152 fi
2153 
2154 if test "$ac_init_help" = "recursive"; then
2155   # If there are subdirs, report their specific --help.
2156   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
2157     test -d "$ac_dir" ||
2158       { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } ||
2159       continue
2160     ac_builddir=.
2161 
2162 case "$ac_dir" in
2163 .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
2164 *)
2165   ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
2166   # A ".." for each directory in $ac_dir_suffix.
2167   ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
2168   case $ac_top_builddir_sub in
2169   "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
2170   *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
2171   esac ;;
2172 esac
2173 ac_abs_top_builddir=$ac_pwd
2174 ac_abs_builddir=$ac_pwd$ac_dir_suffix
2175 # for backward compatibility:
2176 ac_top_builddir=$ac_top_build_prefix
2177 
2178 case $srcdir in
2179   .)  # We are building in place.
2180     ac_srcdir=.
2181     ac_top_srcdir=$ac_top_builddir_sub
2182     ac_abs_top_srcdir=$ac_pwd ;;
2183   [\\/]* | ?:[\\/]* )  # Absolute name.
2184     ac_srcdir=$srcdir$ac_dir_suffix;
2185     ac_top_srcdir=$srcdir
2186     ac_abs_top_srcdir=$srcdir ;;
2187   *) # Relative name.
2188     ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
2189     ac_top_srcdir=$ac_top_build_prefix$srcdir
2190     ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
2191 esac
2192 ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
2193 
2194     cd "$ac_dir" || { ac_status=$?; continue; }
2195     # Check for guested configure.
2196     if test -f "$ac_srcdir/configure.gnu"; then
2197       echo &&
2198       $SHELL "$ac_srcdir/configure.gnu" --help=recursive
2199     elif test -f "$ac_srcdir/configure"; then
2200       echo &&
2201       $SHELL "$ac_srcdir/configure" --help=recursive
2202     else
2203       $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
2204     fi || ac_status=$?
2205     cd "$ac_pwd" || { ac_status=$?; break; }
2206   done
2207 fi
2208 
2209 test -n "$ac_init_help" && exit $ac_status
2210 if $ac_init_version; then
2211   cat <<\_ACEOF
2212 OpenJDK configure jdk9
2213 generated by GNU Autoconf 2.69
2214 
2215 Copyright (C) 2012 Free Software Foundation, Inc.
2216 This configure script is free software; the Free Software Foundation
2217 gives unlimited permission to copy, distribute and modify it.
2218 _ACEOF
2219   exit
2220 fi
2221 
2222 ## ------------------------ ##
2223 ## Autoconf initialization. ##
2224 ## ------------------------ ##
2225 
2226 # ac_fn_c_try_compile LINENO
2227 # --------------------------
2228 # Try to compile conftest.$ac_ext, and return whether this succeeded.
2229 ac_fn_c_try_compile ()
2230 {
2231   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2232   rm -f conftest.$ac_objext
2233   if { { ac_try="$ac_compile"
2234 case "(($ac_try" in
2235   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2236   *) ac_try_echo=$ac_try;;
2237 esac
2238 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2239 $as_echo "$ac_try_echo"; } >&5
2240   (eval "$ac_compile") 2>conftest.err
2241   ac_status=$?
2242   if test -s conftest.err; then
2243     grep -v '^ *+' conftest.err >conftest.er1
2244     cat conftest.er1 >&5
2245     mv -f conftest.er1 conftest.err
2246   fi
2247   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2248   test $ac_status = 0; } && {
2249          test -z "$ac_c_werror_flag" ||
2250          test ! -s conftest.err
2251        } && test -s conftest.$ac_objext; then :
2252   ac_retval=0
2253 else
2254   $as_echo "$as_me: failed program was:" >&5
2255 sed 's/^/| /' conftest.$ac_ext >&5
2256 
2257         ac_retval=1
2258 fi
2259   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2260   as_fn_set_status $ac_retval
2261 
2262 } # ac_fn_c_try_compile
2263 
2264 # ac_fn_cxx_try_compile LINENO
2265 # ----------------------------
2266 # Try to compile conftest.$ac_ext, and return whether this succeeded.
2267 ac_fn_cxx_try_compile ()
2268 {
2269   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2270   rm -f conftest.$ac_objext
2271   if { { ac_try="$ac_compile"
2272 case "(($ac_try" in
2273   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2274   *) ac_try_echo=$ac_try;;
2275 esac
2276 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2277 $as_echo "$ac_try_echo"; } >&5
2278   (eval "$ac_compile") 2>conftest.err
2279   ac_status=$?
2280   if test -s conftest.err; then
2281     grep -v '^ *+' conftest.err >conftest.er1
2282     cat conftest.er1 >&5
2283     mv -f conftest.er1 conftest.err
2284   fi
2285   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2286   test $ac_status = 0; } && {
2287          test -z "$ac_cxx_werror_flag" ||
2288          test ! -s conftest.err
2289        } && test -s conftest.$ac_objext; then :
2290   ac_retval=0
2291 else
2292   $as_echo "$as_me: failed program was:" >&5
2293 sed 's/^/| /' conftest.$ac_ext >&5
2294 
2295         ac_retval=1
2296 fi
2297   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2298   as_fn_set_status $ac_retval
2299 
2300 } # ac_fn_cxx_try_compile
2301 
2302 # ac_fn_c_try_cpp LINENO
2303 # ----------------------
2304 # Try to preprocess conftest.$ac_ext, and return whether this succeeded.
2305 ac_fn_c_try_cpp ()
2306 {
2307   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2308   if { { ac_try="$ac_cpp conftest.$ac_ext"
2309 case "(($ac_try" in
2310   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2311   *) ac_try_echo=$ac_try;;
2312 esac
2313 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2314 $as_echo "$ac_try_echo"; } >&5
2315   (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
2316   ac_status=$?
2317   if test -s conftest.err; then
2318     grep -v '^ *+' conftest.err >conftest.er1
2319     cat conftest.er1 >&5
2320     mv -f conftest.er1 conftest.err
2321   fi
2322   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2323   test $ac_status = 0; } > conftest.i && {
2324          test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
2325          test ! -s conftest.err
2326        }; then :
2327   ac_retval=0
2328 else
2329   $as_echo "$as_me: failed program was:" >&5
2330 sed 's/^/| /' conftest.$ac_ext >&5
2331 
2332     ac_retval=1
2333 fi
2334   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2335   as_fn_set_status $ac_retval
2336 
2337 } # ac_fn_c_try_cpp
2338 
2339 # ac_fn_cxx_try_cpp LINENO
2340 # ------------------------
2341 # Try to preprocess conftest.$ac_ext, and return whether this succeeded.
2342 ac_fn_cxx_try_cpp ()
2343 {
2344   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2345   if { { ac_try="$ac_cpp conftest.$ac_ext"
2346 case "(($ac_try" in
2347   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2348   *) ac_try_echo=$ac_try;;
2349 esac
2350 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2351 $as_echo "$ac_try_echo"; } >&5
2352   (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
2353   ac_status=$?
2354   if test -s conftest.err; then
2355     grep -v '^ *+' conftest.err >conftest.er1
2356     cat conftest.er1 >&5
2357     mv -f conftest.er1 conftest.err
2358   fi
2359   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2360   test $ac_status = 0; } > conftest.i && {
2361          test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
2362          test ! -s conftest.err
2363        }; then :
2364   ac_retval=0
2365 else
2366   $as_echo "$as_me: failed program was:" >&5
2367 sed 's/^/| /' conftest.$ac_ext >&5
2368 
2369     ac_retval=1
2370 fi
2371   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2372   as_fn_set_status $ac_retval
2373 
2374 } # ac_fn_cxx_try_cpp
2375 
2376 # ac_fn_c_try_link LINENO
2377 # -----------------------
2378 # Try to link conftest.$ac_ext, and return whether this succeeded.
2379 ac_fn_c_try_link ()
2380 {
2381   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2382   rm -f conftest.$ac_objext conftest$ac_exeext
2383   if { { ac_try="$ac_link"
2384 case "(($ac_try" in
2385   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2386   *) ac_try_echo=$ac_try;;
2387 esac
2388 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2389 $as_echo "$ac_try_echo"; } >&5
2390   (eval "$ac_link") 2>conftest.err
2391   ac_status=$?
2392   if test -s conftest.err; then
2393     grep -v '^ *+' conftest.err >conftest.er1
2394     cat conftest.er1 >&5
2395     mv -f conftest.er1 conftest.err
2396   fi
2397   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2398   test $ac_status = 0; } && {
2399          test -z "$ac_c_werror_flag" ||
2400          test ! -s conftest.err
2401        } && test -s conftest$ac_exeext && {
2402          test "$cross_compiling" = yes ||
2403          test -x conftest$ac_exeext
2404        }; then :
2405   ac_retval=0
2406 else
2407   $as_echo "$as_me: failed program was:" >&5
2408 sed 's/^/| /' conftest.$ac_ext >&5
2409 
2410         ac_retval=1
2411 fi
2412   # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
2413   # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
2414   # interfere with the next link command; also delete a directory that is
2415   # left behind by Apple's compiler.  We do this before executing the actions.
2416   rm -rf conftest.dSYM conftest_ipa8_conftest.oo
2417   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2418   as_fn_set_status $ac_retval
2419 
2420 } # ac_fn_c_try_link
2421 
2422 # ac_fn_cxx_check_header_mongrel LINENO HEADER VAR INCLUDES
2423 # ---------------------------------------------------------
2424 # Tests whether HEADER exists, giving a warning if it cannot be compiled using
2425 # the include files in INCLUDES and setting the cache variable VAR
2426 # accordingly.
2427 ac_fn_cxx_check_header_mongrel ()
2428 {
2429   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2430   if eval \${$3+:} false; then :
2431   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2432 $as_echo_n "checking for $2... " >&6; }
2433 if eval \${$3+:} false; then :
2434   $as_echo_n "(cached) " >&6
2435 fi
2436 eval ac_res=\$$3
2437                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2438 $as_echo "$ac_res" >&6; }
2439 else
2440   # Is the header compilable?
2441 { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
2442 $as_echo_n "checking $2 usability... " >&6; }
2443 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2444 /* end confdefs.h.  */
2445 $4
2446 #include <$2>
2447 _ACEOF
2448 if ac_fn_cxx_try_compile "$LINENO"; then :
2449   ac_header_compiler=yes
2450 else
2451   ac_header_compiler=no
2452 fi
2453 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2454 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
2455 $as_echo "$ac_header_compiler" >&6; }
2456 
2457 # Is the header present?
2458 { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
2459 $as_echo_n "checking $2 presence... " >&6; }
2460 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2461 /* end confdefs.h.  */
2462 #include <$2>
2463 _ACEOF
2464 if ac_fn_cxx_try_cpp "$LINENO"; then :
2465   ac_header_preproc=yes
2466 else
2467   ac_header_preproc=no
2468 fi
2469 rm -f conftest.err conftest.i conftest.$ac_ext
2470 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
2471 $as_echo "$ac_header_preproc" >&6; }
2472 
2473 # So?  What about this header?
2474 case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in #((
2475   yes:no: )
2476     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
2477 $as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
2478     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
2479 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
2480     ;;
2481   no:yes:* )
2482     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
2483 $as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
2484     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     check for missing prerequisite headers?" >&5
2485 $as_echo "$as_me: WARNING: $2:     check for missing prerequisite headers?" >&2;}
2486     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
2487 $as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
2488     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&5
2489 $as_echo "$as_me: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&2;}
2490     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
2491 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
2492 ( $as_echo "## ----------------------------------------- ##
2493 ## Report this to build-dev@openjdk.java.net ##
2494 ## ----------------------------------------- ##"
2495      ) | sed "s/^/$as_me: WARNING:     /" >&2
2496     ;;
2497 esac
2498   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2499 $as_echo_n "checking for $2... " >&6; }
2500 if eval \${$3+:} false; then :
2501   $as_echo_n "(cached) " >&6
2502 else
2503   eval "$3=\$ac_header_compiler"
2504 fi
2505 eval ac_res=\$$3
2506                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2507 $as_echo "$ac_res" >&6; }
2508 fi
2509   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2510 
2511 } # ac_fn_cxx_check_header_mongrel
2512 
2513 # ac_fn_cxx_try_run LINENO
2514 # ------------------------
2515 # Try to link conftest.$ac_ext, and return whether this succeeded. Assumes
2516 # that executables *can* be run.
2517 ac_fn_cxx_try_run ()
2518 {
2519   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2520   if { { ac_try="$ac_link"
2521 case "(($ac_try" in
2522   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2523   *) ac_try_echo=$ac_try;;
2524 esac
2525 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2526 $as_echo "$ac_try_echo"; } >&5
2527   (eval "$ac_link") 2>&5
2528   ac_status=$?
2529   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2530   test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'
2531   { { case "(($ac_try" in
2532   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2533   *) ac_try_echo=$ac_try;;
2534 esac
2535 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2536 $as_echo "$ac_try_echo"; } >&5
2537   (eval "$ac_try") 2>&5
2538   ac_status=$?
2539   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2540   test $ac_status = 0; }; }; then :
2541   ac_retval=0
2542 else
2543   $as_echo "$as_me: program exited with status $ac_status" >&5
2544        $as_echo "$as_me: failed program was:" >&5
2545 sed 's/^/| /' conftest.$ac_ext >&5
2546 
2547        ac_retval=$ac_status
2548 fi
2549   rm -rf conftest.dSYM conftest_ipa8_conftest.oo
2550   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2551   as_fn_set_status $ac_retval
2552 
2553 } # ac_fn_cxx_try_run
2554 
2555 # ac_fn_cxx_check_header_compile LINENO HEADER VAR INCLUDES
2556 # ---------------------------------------------------------
2557 # Tests whether HEADER exists and can be compiled using the include files in
2558 # INCLUDES, setting the cache variable VAR accordingly.
2559 ac_fn_cxx_check_header_compile ()
2560 {
2561   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2562   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2563 $as_echo_n "checking for $2... " >&6; }
2564 if eval \${$3+:} false; then :
2565   $as_echo_n "(cached) " >&6
2566 else
2567   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2568 /* end confdefs.h.  */
2569 $4
2570 #include <$2>
2571 _ACEOF
2572 if ac_fn_cxx_try_compile "$LINENO"; then :
2573   eval "$3=yes"
2574 else
2575   eval "$3=no"
2576 fi
2577 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2578 fi
2579 eval ac_res=\$$3
2580                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2581 $as_echo "$ac_res" >&6; }
2582   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2583 
2584 } # ac_fn_cxx_check_header_compile
2585 
2586 # ac_fn_cxx_compute_int LINENO EXPR VAR INCLUDES
2587 # ----------------------------------------------
2588 # Tries to find the compile-time value of EXPR in a program that includes
2589 # INCLUDES, setting VAR accordingly. Returns whether the value could be
2590 # computed
2591 ac_fn_cxx_compute_int ()
2592 {
2593   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2594   if test "$cross_compiling" = yes; then
2595     # Depending upon the size, compute the lo and hi bounds.
2596 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2597 /* end confdefs.h.  */
2598 $4
2599 int
2600 main ()
2601 {
2602 static int test_array [1 - 2 * !(($2) >= 0)];
2603 test_array [0] = 0;
2604 return test_array [0];
2605 
2606   ;
2607   return 0;
2608 }
2609 _ACEOF
2610 if ac_fn_cxx_try_compile "$LINENO"; then :
2611   ac_lo=0 ac_mid=0
2612   while :; do
2613     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2614 /* end confdefs.h.  */
2615 $4
2616 int
2617 main ()
2618 {
2619 static int test_array [1 - 2 * !(($2) <= $ac_mid)];
2620 test_array [0] = 0;
2621 return test_array [0];
2622 
2623   ;
2624   return 0;
2625 }
2626 _ACEOF
2627 if ac_fn_cxx_try_compile "$LINENO"; then :
2628   ac_hi=$ac_mid; break
2629 else
2630   as_fn_arith $ac_mid + 1 && ac_lo=$as_val
2631                         if test $ac_lo -le $ac_mid; then
2632                           ac_lo= ac_hi=
2633                           break
2634                         fi
2635                         as_fn_arith 2 '*' $ac_mid + 1 && ac_mid=$as_val
2636 fi
2637 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2638   done
2639 else
2640   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2641 /* end confdefs.h.  */
2642 $4
2643 int
2644 main ()
2645 {
2646 static int test_array [1 - 2 * !(($2) < 0)];
2647 test_array [0] = 0;
2648 return test_array [0];
2649 
2650   ;
2651   return 0;
2652 }
2653 _ACEOF
2654 if ac_fn_cxx_try_compile "$LINENO"; then :
2655   ac_hi=-1 ac_mid=-1
2656   while :; do
2657     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2658 /* end confdefs.h.  */
2659 $4
2660 int
2661 main ()
2662 {
2663 static int test_array [1 - 2 * !(($2) >= $ac_mid)];
2664 test_array [0] = 0;
2665 return test_array [0];
2666 
2667   ;
2668   return 0;
2669 }
2670 _ACEOF
2671 if ac_fn_cxx_try_compile "$LINENO"; then :
2672   ac_lo=$ac_mid; break
2673 else
2674   as_fn_arith '(' $ac_mid ')' - 1 && ac_hi=$as_val
2675                         if test $ac_mid -le $ac_hi; then
2676                           ac_lo= ac_hi=
2677                           break
2678                         fi
2679                         as_fn_arith 2 '*' $ac_mid && ac_mid=$as_val
2680 fi
2681 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2682   done
2683 else
2684   ac_lo= ac_hi=
2685 fi
2686 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2687 fi
2688 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2689 # Binary search between lo and hi bounds.
2690 while test "x$ac_lo" != "x$ac_hi"; do
2691   as_fn_arith '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo && ac_mid=$as_val
2692   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2693 /* end confdefs.h.  */
2694 $4
2695 int
2696 main ()
2697 {
2698 static int test_array [1 - 2 * !(($2) <= $ac_mid)];
2699 test_array [0] = 0;
2700 return test_array [0];
2701 
2702   ;
2703   return 0;
2704 }
2705 _ACEOF
2706 if ac_fn_cxx_try_compile "$LINENO"; then :
2707   ac_hi=$ac_mid
2708 else
2709   as_fn_arith '(' $ac_mid ')' + 1 && ac_lo=$as_val
2710 fi
2711 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2712 done
2713 case $ac_lo in #((
2714 ?*) eval "$3=\$ac_lo"; ac_retval=0 ;;
2715 '') ac_retval=1 ;;
2716 esac
2717   else
2718     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2719 /* end confdefs.h.  */
2720 $4
2721 static long int longval () { return $2; }
2722 static unsigned long int ulongval () { return $2; }
2723 #include <stdio.h>
2724 #include <stdlib.h>
2725 int
2726 main ()
2727 {
2728 
2729   FILE *f = fopen ("conftest.val", "w");
2730   if (! f)
2731     return 1;
2732   if (($2) < 0)
2733     {
2734       long int i = longval ();
2735       if (i != ($2))
2736         return 1;
2737       fprintf (f, "%ld", i);
2738     }
2739   else
2740     {
2741       unsigned long int i = ulongval ();
2742       if (i != ($2))
2743         return 1;
2744       fprintf (f, "%lu", i);
2745     }
2746   /* Do not output a trailing newline, as this causes \r\n confusion
2747      on some platforms.  */
2748   return ferror (f) || fclose (f) != 0;
2749 
2750   ;
2751   return 0;
2752 }
2753 _ACEOF
2754 if ac_fn_cxx_try_run "$LINENO"; then :
2755   echo >>conftest.val; read $3 <conftest.val; ac_retval=0
2756 else
2757   ac_retval=1
2758 fi
2759 rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
2760   conftest.$ac_objext conftest.beam conftest.$ac_ext
2761 rm -f conftest.val
2762 
2763   fi
2764   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2765   as_fn_set_status $ac_retval
2766 
2767 } # ac_fn_cxx_compute_int
2768 
2769 # ac_fn_cxx_try_link LINENO
2770 # -------------------------
2771 # Try to link conftest.$ac_ext, and return whether this succeeded.
2772 ac_fn_cxx_try_link ()
2773 {
2774   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2775   rm -f conftest.$ac_objext conftest$ac_exeext
2776   if { { ac_try="$ac_link"
2777 case "(($ac_try" in
2778   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2779   *) ac_try_echo=$ac_try;;
2780 esac
2781 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2782 $as_echo "$ac_try_echo"; } >&5
2783   (eval "$ac_link") 2>conftest.err
2784   ac_status=$?
2785   if test -s conftest.err; then
2786     grep -v '^ *+' conftest.err >conftest.er1
2787     cat conftest.er1 >&5
2788     mv -f conftest.er1 conftest.err
2789   fi
2790   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2791   test $ac_status = 0; } && {
2792          test -z "$ac_cxx_werror_flag" ||
2793          test ! -s conftest.err
2794        } && test -s conftest$ac_exeext && {
2795          test "$cross_compiling" = yes ||
2796          test -x conftest$ac_exeext
2797        }; then :
2798   ac_retval=0
2799 else
2800   $as_echo "$as_me: failed program was:" >&5
2801 sed 's/^/| /' conftest.$ac_ext >&5
2802 
2803         ac_retval=1
2804 fi
2805   # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
2806   # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
2807   # interfere with the next link command; also delete a directory that is
2808   # left behind by Apple's compiler.  We do this before executing the actions.
2809   rm -rf conftest.dSYM conftest_ipa8_conftest.oo
2810   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2811   as_fn_set_status $ac_retval
2812 
2813 } # ac_fn_cxx_try_link
2814 
2815 # ac_fn_cxx_check_func LINENO FUNC VAR
2816 # ------------------------------------
2817 # Tests whether FUNC exists, setting the cache variable VAR accordingly
2818 ac_fn_cxx_check_func ()
2819 {
2820   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2821   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2822 $as_echo_n "checking for $2... " >&6; }
2823 if eval \${$3+:} false; then :
2824   $as_echo_n "(cached) " >&6
2825 else
2826   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2827 /* end confdefs.h.  */
2828 /* Define $2 to an innocuous variant, in case <limits.h> declares $2.
2829    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
2830 #define $2 innocuous_$2
2831 
2832 /* System header to define __stub macros and hopefully few prototypes,
2833     which can conflict with char $2 (); below.
2834     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
2835     <limits.h> exists even on freestanding compilers.  */
2836 
2837 #ifdef __STDC__
2838 # include <limits.h>
2839 #else
2840 # include <assert.h>
2841 #endif
2842 
2843 #undef $2
2844 
2845 /* Override any GCC internal prototype to avoid an error.
2846    Use char because int might match the return type of a GCC
2847    builtin and then its argument prototype would still apply.  */
2848 #ifdef __cplusplus
2849 extern "C"
2850 #endif
2851 char $2 ();
2852 /* The GNU C library defines this for functions which it implements
2853     to always fail with ENOSYS.  Some functions are actually named
2854     something starting with __ and the normal name is an alias.  */
2855 #if defined __stub_$2 || defined __stub___$2
2856 choke me
2857 #endif
2858 
2859 int
2860 main ()
2861 {
2862 return $2 ();
2863   ;
2864   return 0;
2865 }
2866 _ACEOF
2867 if ac_fn_cxx_try_link "$LINENO"; then :
2868   eval "$3=yes"
2869 else
2870   eval "$3=no"
2871 fi
2872 rm -f core conftest.err conftest.$ac_objext \
2873     conftest$ac_exeext conftest.$ac_ext
2874 fi
2875 eval ac_res=\$$3
2876                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2877 $as_echo "$ac_res" >&6; }
2878   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2879 
2880 } # ac_fn_cxx_check_func
2881 
2882 # ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES
2883 # -------------------------------------------------------
2884 # Tests whether HEADER exists and can be compiled using the include files in
2885 # INCLUDES, setting the cache variable VAR accordingly.
2886 ac_fn_c_check_header_compile ()
2887 {
2888   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2889   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2890 $as_echo_n "checking for $2... " >&6; }
2891 if eval \${$3+:} false; then :
2892   $as_echo_n "(cached) " >&6
2893 else
2894   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2895 /* end confdefs.h.  */
2896 $4
2897 #include <$2>
2898 _ACEOF
2899 if ac_fn_c_try_compile "$LINENO"; then :
2900   eval "$3=yes"
2901 else
2902   eval "$3=no"
2903 fi
2904 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2905 fi
2906 eval ac_res=\$$3
2907                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2908 $as_echo "$ac_res" >&6; }
2909   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2910 
2911 } # ac_fn_c_check_header_compile
2912 cat >config.log <<_ACEOF
2913 This file contains any messages produced by compilers while
2914 running configure, to aid debugging if configure makes a mistake.
2915 
2916 It was created by OpenJDK $as_me jdk9, which was
2917 generated by GNU Autoconf 2.69.  Invocation command line was
2918 
2919   $ $0 $@
2920 
2921 _ACEOF
2922 exec 5>>config.log
2923 {
2924 cat <<_ASUNAME
2925 ## --------- ##
2926 ## Platform. ##
2927 ## --------- ##
2928 
2929 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
2930 uname -m = `(uname -m) 2>/dev/null || echo unknown`
2931 uname -r = `(uname -r) 2>/dev/null || echo unknown`
2932 uname -s = `(uname -s) 2>/dev/null || echo unknown`
2933 uname -v = `(uname -v) 2>/dev/null || echo unknown`
2934 
2935 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
2936 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
2937 
2938 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
2939 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
2940 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
2941 /usr/bin/hostinfo      = `(/usr/bin/hostinfo) 2>/dev/null      || echo unknown`
2942 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
2943 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
2944 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
2945 
2946 _ASUNAME
2947 
2948 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2949 for as_dir in $PATH
2950 do
2951   IFS=$as_save_IFS
2952   test -z "$as_dir" && as_dir=.
2953     $as_echo "PATH: $as_dir"
2954   done
2955 IFS=$as_save_IFS
2956 
2957 } >&5
2958 
2959 cat >&5 <<_ACEOF
2960 
2961 
2962 ## ----------- ##
2963 ## Core tests. ##
2964 ## ----------- ##
2965 
2966 _ACEOF
2967 
2968 
2969 # Keep a trace of the command line.
2970 # Strip out --no-create and --no-recursion so they do not pile up.
2971 # Strip out --silent because we don't want to record it for future runs.
2972 # Also quote any args containing shell meta-characters.
2973 # Make two passes to allow for proper duplicate-argument suppression.
2974 ac_configure_args=
2975 ac_configure_args0=
2976 ac_configure_args1=
2977 ac_must_keep_next=false
2978 for ac_pass in 1 2
2979 do
2980   for ac_arg
2981   do
2982     case $ac_arg in
2983     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
2984     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
2985     | -silent | --silent | --silen | --sile | --sil)
2986       continue ;;
2987     *\'*)
2988       ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
2989     esac
2990     case $ac_pass in
2991     1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;
2992     2)
2993       as_fn_append ac_configure_args1 " '$ac_arg'"
2994       if test $ac_must_keep_next = true; then
2995         ac_must_keep_next=false # Got value, back to normal.
2996       else
2997         case $ac_arg in
2998           *=* | --config-cache | -C | -disable-* | --disable-* \
2999           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
3000           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
3001           | -with-* | --with-* | -without-* | --without-* | --x)
3002             case "$ac_configure_args0 " in
3003               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
3004             esac
3005             ;;
3006           -* ) ac_must_keep_next=true ;;
3007         esac
3008       fi
3009       as_fn_append ac_configure_args " '$ac_arg'"
3010       ;;
3011     esac
3012   done
3013 done
3014 { ac_configure_args0=; unset ac_configure_args0;}
3015 { ac_configure_args1=; unset ac_configure_args1;}
3016 
3017 # When interrupted or exit'd, cleanup temporary files, and complete
3018 # config.log.  We remove comments because anyway the quotes in there
3019 # would cause problems or look ugly.
3020 # WARNING: Use '\'' to represent an apostrophe within the trap.
3021 # WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.
3022 trap 'exit_status=$?
3023   # Save into config.log some information that might help in debugging.
3024   {
3025     echo
3026 
3027     $as_echo "## ---------------- ##
3028 ## Cache variables. ##
3029 ## ---------------- ##"
3030     echo
3031     # The following way of writing the cache mishandles newlines in values,
3032 (
3033   for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do
3034     eval ac_val=\$$ac_var
3035     case $ac_val in #(
3036     *${as_nl}*)
3037       case $ac_var in #(
3038       *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
3039 $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
3040       esac
3041       case $ac_var in #(
3042       _ | IFS | as_nl) ;; #(
3043       BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
3044       *) { eval $ac_var=; unset $ac_var;} ;;
3045       esac ;;
3046     esac
3047   done
3048   (set) 2>&1 |
3049     case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #(
3050     *${as_nl}ac_space=\ *)
3051       sed -n \
3052         "s/'\''/'\''\\\\'\'''\''/g;
3053           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p"
3054       ;; #(
3055     *)
3056       sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
3057       ;;
3058     esac |
3059     sort
3060 )
3061     echo
3062 
3063     $as_echo "## ----------------- ##
3064 ## Output variables. ##
3065 ## ----------------- ##"
3066     echo
3067     for ac_var in $ac_subst_vars
3068     do
3069       eval ac_val=\$$ac_var
3070       case $ac_val in
3071       *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
3072       esac
3073       $as_echo "$ac_var='\''$ac_val'\''"
3074     done | sort
3075     echo
3076 
3077     if test -n "$ac_subst_files"; then
3078       $as_echo "## ------------------- ##
3079 ## File substitutions. ##
3080 ## ------------------- ##"
3081       echo
3082       for ac_var in $ac_subst_files
3083       do
3084         eval ac_val=\$$ac_var
3085         case $ac_val in
3086         *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
3087         esac
3088         $as_echo "$ac_var='\''$ac_val'\''"
3089       done | sort
3090       echo
3091     fi
3092 
3093     if test -s confdefs.h; then
3094       $as_echo "## ----------- ##
3095 ## confdefs.h. ##
3096 ## ----------- ##"
3097       echo
3098       cat confdefs.h
3099       echo
3100     fi
3101     test "$ac_signal" != 0 &&
3102       $as_echo "$as_me: caught signal $ac_signal"
3103     $as_echo "$as_me: exit $exit_status"
3104   } >&5
3105   rm -f core *.core core.conftest.* &&
3106     rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
3107     exit $exit_status
3108 ' 0
3109 for ac_signal in 1 2 13 15; do
3110   trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal
3111 done
3112 ac_signal=0
3113 
3114 # confdefs.h avoids OS command line length limits that DEFS can exceed.
3115 rm -f -r conftest* confdefs.h
3116 
3117 $as_echo "/* confdefs.h */" > confdefs.h
3118 
3119 # Predefined preprocessor variables.
3120 
3121 cat >>confdefs.h <<_ACEOF
3122 #define PACKAGE_NAME "$PACKAGE_NAME"
3123 _ACEOF
3124 
3125 cat >>confdefs.h <<_ACEOF
3126 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
3127 _ACEOF
3128 
3129 cat >>confdefs.h <<_ACEOF
3130 #define PACKAGE_VERSION "$PACKAGE_VERSION"
3131 _ACEOF
3132 
3133 cat >>confdefs.h <<_ACEOF
3134 #define PACKAGE_STRING "$PACKAGE_STRING"
3135 _ACEOF
3136 
3137 cat >>confdefs.h <<_ACEOF
3138 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
3139 _ACEOF
3140 
3141 cat >>confdefs.h <<_ACEOF
3142 #define PACKAGE_URL "$PACKAGE_URL"
3143 _ACEOF
3144 
3145 
3146 # Let the site file select an alternate cache file if it wants to.
3147 # Prefer an explicitly selected file to automatically selected ones.
3148 ac_site_file1=NONE
3149 ac_site_file2=NONE
3150 if test -n "$CONFIG_SITE"; then
3151   # We do not want a PATH search for config.site.
3152   case $CONFIG_SITE in #((
3153     -*)  ac_site_file1=./$CONFIG_SITE;;
3154     */*) ac_site_file1=$CONFIG_SITE;;
3155     *)   ac_site_file1=./$CONFIG_SITE;;
3156   esac
3157 elif test "x$prefix" != xNONE; then
3158   ac_site_file1=$prefix/share/config.site
3159   ac_site_file2=$prefix/etc/config.site
3160 else
3161   ac_site_file1=$ac_default_prefix/share/config.site
3162   ac_site_file2=$ac_default_prefix/etc/config.site
3163 fi
3164 for ac_site_file in "$ac_site_file1" "$ac_site_file2"
3165 do
3166   test "x$ac_site_file" = xNONE && continue
3167   if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then
3168     { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
3169 $as_echo "$as_me: loading site script $ac_site_file" >&6;}
3170     sed 's/^/| /' "$ac_site_file" >&5
3171     . "$ac_site_file" \
3172       || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3173 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3174 as_fn_error $? "failed to load site script $ac_site_file
3175 See \`config.log' for more details" "$LINENO" 5; }
3176   fi
3177 done
3178 
3179 if test -r "$cache_file"; then
3180   # Some versions of bash will fail to source /dev/null (special files
3181   # actually), so we avoid doing that.  DJGPP emulates it as a regular file.
3182   if test /dev/null != "$cache_file" && test -f "$cache_file"; then
3183     { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
3184 $as_echo "$as_me: loading cache $cache_file" >&6;}
3185     case $cache_file in
3186       [\\/]* | ?:[\\/]* ) . "$cache_file";;
3187       *)                      . "./$cache_file";;
3188     esac
3189   fi
3190 else
3191   { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
3192 $as_echo "$as_me: creating cache $cache_file" >&6;}
3193   >$cache_file
3194 fi
3195 
3196 # Check that the precious variables saved in the cache have kept the same
3197 # value.
3198 ac_cache_corrupted=false
3199 for ac_var in $ac_precious_vars; do
3200   eval ac_old_set=\$ac_cv_env_${ac_var}_set
3201   eval ac_new_set=\$ac_env_${ac_var}_set
3202   eval ac_old_val=\$ac_cv_env_${ac_var}_value
3203   eval ac_new_val=\$ac_env_${ac_var}_value
3204   case $ac_old_set,$ac_new_set in
3205     set,)
3206       { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
3207 $as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
3208       ac_cache_corrupted=: ;;
3209     ,set)
3210       { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5
3211 $as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
3212       ac_cache_corrupted=: ;;
3213     ,);;
3214     *)
3215       if test "x$ac_old_val" != "x$ac_new_val"; then
3216         # differences in whitespace do not lead to failure.
3217         ac_old_val_w=`echo x $ac_old_val`
3218         ac_new_val_w=`echo x $ac_new_val`
3219         if test "$ac_old_val_w" != "$ac_new_val_w"; then
3220           { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5
3221 $as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
3222           ac_cache_corrupted=:
3223         else
3224           { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
3225 $as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
3226           eval $ac_var=\$ac_old_val
3227         fi
3228         { $as_echo "$as_me:${as_lineno-$LINENO}:   former value:  \`$ac_old_val'" >&5
3229 $as_echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
3230         { $as_echo "$as_me:${as_lineno-$LINENO}:   current value: \`$ac_new_val'" >&5
3231 $as_echo "$as_me:   current value: \`$ac_new_val'" >&2;}
3232       fi;;
3233   esac
3234   # Pass precious variables to config.status.
3235   if test "$ac_new_set" = set; then
3236     case $ac_new_val in
3237     *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
3238     *) ac_arg=$ac_var=$ac_new_val ;;
3239     esac
3240     case " $ac_configure_args " in
3241       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
3242       *) as_fn_append ac_configure_args " '$ac_arg'" ;;
3243     esac
3244   fi
3245 done
3246 if $ac_cache_corrupted; then
3247   { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3248 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3249   { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
3250 $as_echo "$as_me: error: changes in the environment can compromise the build" >&2;}
3251   as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5
3252 fi
3253 ## -------------------- ##
3254 ## Main body of script. ##
3255 ## -------------------- ##
3256 
3257 ac_ext=c
3258 ac_cpp='$CPP $CPPFLAGS'
3259 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3260 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3261 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3262 
3263 
3264 
3265 ac_aux_dir=
3266 for ac_dir in $TOPDIR/common/autoconf/build-aux "$srcdir"/$TOPDIR/common/autoconf/build-aux; do
3267   if test -f "$ac_dir/install-sh"; then
3268     ac_aux_dir=$ac_dir
3269     ac_install_sh="$ac_aux_dir/install-sh -c"
3270     break
3271   elif test -f "$ac_dir/install.sh"; then
3272     ac_aux_dir=$ac_dir
3273     ac_install_sh="$ac_aux_dir/install.sh -c"
3274     break
3275   elif test -f "$ac_dir/shtool"; then
3276     ac_aux_dir=$ac_dir
3277     ac_install_sh="$ac_aux_dir/shtool install -c"
3278     break
3279   fi
3280 done
3281 if test -z "$ac_aux_dir"; then
3282   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
3283 fi
3284 
3285 # These three variables are undocumented and unsupported,
3286 # and are intended to be withdrawn in a future Autoconf release.
3287 # They can cause serious problems if a builder's source tree is in a directory
3288 # whose full name contains unusual characters.
3289 ac_config_guess="$SHELL $ac_aux_dir/config.guess"  # Please don't use this var.
3290 ac_config_sub="$SHELL $ac_aux_dir/config.sub"  # Please don't use this var.
3291 ac_configure="$SHELL $ac_aux_dir/configure"  # Please don't use this var.
3292 
3293 
3294 # pkg.m4 - Macros to locate and utilise pkg-config.            -*- Autoconf -*-
3295 
3296 #
3297 # Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
3298 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3299 #
3300 # This code is free software; you can redistribute it and/or modify it
3301 # under the terms of the GNU General Public License version 2 only, as
3302 # published by the Free Software Foundation.  Oracle designates this
3303 # particular file as subject to the "Classpath" exception as provided
3304 # by Oracle in the LICENSE file that accompanied this code.
3305 #
3306 # This code is distributed in the hope that it will be useful, but WITHOUT
3307 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3308 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3309 # version 2 for more details (a copy is included in the LICENSE file that
3310 # accompanied this code).
3311 #
3312 # You should have received a copy of the GNU General Public License version
3313 # 2 along with this work; if not, write to the Free Software Foundation,
3314 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3315 #
3316 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3317 # or visit www.oracle.com if you need additional information or have any
3318 # questions.
3319 #
3320 
3321 #
3322 # Copyright © 2004 Scott James Remnant <scott@netsplit.com>.
3323 #
3324 # This program is free software; you can redistribute it and/or modify
3325 # it under the terms of the GNU General Public License as published by
3326 # the Free Software Foundation; either version 2 of the License, or
3327 # (at your option) any later version.
3328 #
3329 # This program is distributed in the hope that it will be useful, but
3330 # WITHOUT ANY WARRANTY; without even the implied warranty of
3331 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
3332 # General Public License for more details.
3333 #
3334 # You should have received a copy of the GNU General Public License
3335 # along with this program; if not, write to the Free Software
3336 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
3337 #
3338 # As a special exception to the GNU General Public License, if you
3339 # distribute this file as part of a program that contains a
3340 # configuration script generated by Autoconf, you may include it under
3341 # the same distribution terms that you use for the rest of that program.
3342 
3343 # PKG_PROG_PKG_CONFIG([MIN-VERSION])
3344 # ----------------------------------
3345 # PKG_PROG_PKG_CONFIG
3346 
3347 # PKG_CHECK_EXISTS(MODULES, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
3348 #
3349 # Check to see whether a particular set of modules exists.  Similar
3350 # to PKG_CHECK_MODULES(), but does not set variables or print errors.
3351 #
3352 #
3353 # Similar to PKG_CHECK_MODULES, make sure that the first instance of
3354 # this or PKG_CHECK_MODULES is called, or make sure to call
3355 # PKG_CHECK_EXISTS manually
3356 # --------------------------------------------------------------
3357 
3358 
3359 
3360 # _PKG_CONFIG([VARIABLE], [COMMAND], [MODULES])
3361 # ---------------------------------------------
3362 # _PKG_CONFIG
3363 
3364 # _PKG_SHORT_ERRORS_SUPPORTED
3365 # -----------------------------
3366 # _PKG_SHORT_ERRORS_SUPPORTED
3367 
3368 
3369 # PKG_CHECK_MODULES(VARIABLE-PREFIX, MODULES, [ACTION-IF-FOUND],
3370 # [ACTION-IF-NOT-FOUND])
3371 #
3372 #
3373 # Note that if there is a possibility the first call to
3374 # PKG_CHECK_MODULES might not happen, you should be sure to include an
3375 # explicit call to PKG_PROG_PKG_CONFIG in your configure.ac
3376 #
3377 #
3378 # --------------------------------------------------------------
3379 # PKG_CHECK_MODULES
3380 
3381 
3382 # Include these first...
3383 #
3384 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
3385 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3386 #
3387 # This code is free software; you can redistribute it and/or modify it
3388 # under the terms of the GNU General Public License version 2 only, as
3389 # published by the Free Software Foundation.  Oracle designates this
3390 # particular file as subject to the "Classpath" exception as provided
3391 # by Oracle in the LICENSE file that accompanied this code.
3392 #
3393 # This code is distributed in the hope that it will be useful, but WITHOUT
3394 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3395 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3396 # version 2 for more details (a copy is included in the LICENSE file that
3397 # accompanied this code).
3398 #
3399 # You should have received a copy of the GNU General Public License version
3400 # 2 along with this work; if not, write to the Free Software Foundation,
3401 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3402 #
3403 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3404 # or visit www.oracle.com if you need additional information or have any
3405 # questions.
3406 #
3407 
3408 # Test if $1 is a valid argument to $3 (often is $JAVA passed as $3)
3409 # If so, then append $1 to $2 \
3410 # Also set JVM_ARG_OK to true/false depending on outcome.
3411 
3412 
3413 # Appends a string to a path variable, only adding the : when needed.
3414 
3415 
3416 # Prepends a string to a path variable, only adding the : when needed.
3417 
3418 
3419 # This will make sure the given variable points to a full and proper
3420 # path. This means:
3421 # 1) There will be no spaces in the path. On unix platforms,
3422 #    spaces in the path will result in an error. On Windows,
3423 #    the path will be rewritten using short-style to be space-free.
3424 # 2) The path will be absolute, and it will be in unix-style (on
3425 #     cygwin).
3426 # $1: The name of the variable to fix
3427 
3428 
3429 # This will make sure the given variable points to a executable
3430 # with a full and proper path. This means:
3431 # 1) There will be no spaces in the path. On unix platforms,
3432 #    spaces in the path will result in an error. On Windows,
3433 #    the path will be rewritten using short-style to be space-free.
3434 # 2) The path will be absolute, and it will be in unix-style (on
3435 #     cygwin).
3436 # Any arguments given to the executable is preserved.
3437 # If the input variable does not have a directory specification, then
3438 # it need to be in the PATH.
3439 # $1: The name of the variable to fix
3440 
3441 
3442 
3443 
3444 # Register a --with argument but mark it as deprecated
3445 # $1: The name of the with argument to deprecate, not including --with-
3446 
3447 
3448 # Register a --enable argument but mark it as deprecated
3449 # $1: The name of the with argument to deprecate, not including --enable-
3450 # $2: The name of the argument to deprecate, in shell variable style (i.e. with _ instead of -)
3451 
3452 
3453 
3454 
3455 # Test that variable $1 denoting a program is not empty. If empty, exit with an error.
3456 # $1: variable to check
3457 
3458 
3459 # Check that there are no unprocessed overridden variables left.
3460 # If so, they are an incorrect argument and we will exit with an error.
3461 
3462 
3463 # Setup a tool for the given variable. If correctly specified by the user,
3464 # use that value, otherwise search for the tool using the supplied code snippet.
3465 # $1: variable to set
3466 # $2: code snippet to call to look for the tool
3467 # $3: code snippet to call if variable was used to find tool
3468 
3469 
3470 # Call BASIC_SETUP_TOOL with AC_PATH_PROGS to locate the tool
3471 # $1: variable to set
3472 # $2: executable name (or list of names) to look for
3473 
3474 
3475 # Call BASIC_SETUP_TOOL with AC_CHECK_TOOLS to locate the tool
3476 # $1: variable to set
3477 # $2: executable name (or list of names) to look for
3478 
3479 
3480 # Like BASIC_PATH_PROGS but fails if no tool was found.
3481 # $1: variable to set
3482 # $2: executable name (or list of names) to look for
3483 
3484 
3485 # Like BASIC_SETUP_TOOL but fails if no tool was found.
3486 # $1: variable to set
3487 # $2: autoconf macro to call to look for the special tool
3488 
3489 
3490 # Setup the most fundamental tools that relies on not much else to set up,
3491 # but is used by much of the early bootstrap code.
3492 
3493 
3494 # Setup basic configuration paths, and platform-specific stuff related to PATHs.
3495 
3496 
3497 # Evaluates platform specific overrides for devkit variables.
3498 # $1: Name of variable
3499 
3500 
3501 
3502 
3503 
3504 
3505 #%%% Simple tools %%%
3506 
3507 # Check if we have found a usable version of make
3508 # $1: the path to a potential make binary (or empty)
3509 # $2: the description on how we found this
3510 
3511 
3512 
3513 
3514 # Goes looking for a usable version of GNU make.
3515 
3516 
3517 
3518 
3519 
3520 
3521 # Check if build directory is on local disk. If not possible to determine,
3522 # we prefer to claim it's local.
3523 # Argument 1: directory to test
3524 # Argument 2: what to do if it is on local disk
3525 # Argument 3: what to do otherwise (remote disk or failure)
3526 
3527 
3528 # Check that source files have basic read permissions set. This might
3529 # not be the case in cygwin in certain conditions.
3530 
3531 
3532 
3533 
3534 # Check for support for specific options in bash
3535 
3536 
3537 # Code to run after AC_OUTPUT
3538 
3539 
3540 #
3541 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
3542 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3543 #
3544 # This code is free software; you can redistribute it and/or modify it
3545 # under the terms of the GNU General Public License version 2 only, as
3546 # published by the Free Software Foundation.  Oracle designates this
3547 # particular file as subject to the "Classpath" exception as provided
3548 # by Oracle in the LICENSE file that accompanied this code.
3549 #
3550 # This code is distributed in the hope that it will be useful, but WITHOUT
3551 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3552 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3553 # version 2 for more details (a copy is included in the LICENSE file that
3554 # accompanied this code).
3555 #
3556 # You should have received a copy of the GNU General Public License version
3557 # 2 along with this work; if not, write to the Free Software Foundation,
3558 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3559 #
3560 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3561 # or visit www.oracle.com if you need additional information or have any
3562 # questions.
3563 #
3564 
3565 
3566 
3567 
3568 
3569 # Helper function which possibly converts a path using DOS-style short mode.
3570 # If so, the updated path is stored in $new_path.
3571 # $1: The path to check
3572 
3573 
3574 # Helper function which possibly converts a path using DOS-style short mode.
3575 # If so, the updated path is stored in $new_path.
3576 # $1: The path to check
3577 
3578 
3579 # FIXME: The BASIC_FIXUP_*_CYGWIN/MSYS is most likely too convoluted
3580 # and could probably be heavily simplified. However, all changes in this
3581 # area tend to need lot of testing in different scenarios, and in lack of
3582 # proper unit testing, cleaning this up has not been deemed worth the effort
3583 # at the moment.
3584 
3585 
3586 
3587 
3588 
3589 
3590 
3591 
3592 
3593 # Setup basic configuration paths, and platform-specific stuff related to PATHs.
3594 
3595 
3596 
3597 
3598 # ... then the rest
3599 #
3600 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
3601 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3602 #
3603 # This code is free software; you can redistribute it and/or modify it
3604 # under the terms of the GNU General Public License version 2 only, as
3605 # published by the Free Software Foundation.  Oracle designates this
3606 # particular file as subject to the "Classpath" exception as provided
3607 # by Oracle in the LICENSE file that accompanied this code.
3608 #
3609 # This code is distributed in the hope that it will be useful, but WITHOUT
3610 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3611 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3612 # version 2 for more details (a copy is included in the LICENSE file that
3613 # accompanied this code).
3614 #
3615 # You should have received a copy of the GNU General Public License version
3616 # 2 along with this work; if not, write to the Free Software Foundation,
3617 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3618 #
3619 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3620 # or visit www.oracle.com if you need additional information or have any
3621 # questions.
3622 #
3623 
3624 ########################################################################
3625 # This file handles detection of the Boot JDK. The Boot JDK detection
3626 # process has been developed as a response to solve a complex real-world
3627 # problem. Initially, it was simple, but it has grown as platform after
3628 # platform, idiosyncracy after idiosyncracy has been supported.
3629 #
3630 # The basic idea is this:
3631 # 1) You need an acceptable *) JDK to use as a Boot JDK
3632 # 2) There are several ways to locate a JDK, that are mostly platform
3633 #    dependent **)
3634 # 3) You can have multiple JDKs installed
3635 # 4) If possible, configure should try to dig out an acceptable JDK
3636 #    automatically, without having to resort to command-line options
3637 #
3638 # *)  acceptable means e.g. JDK7 for building JDK8, a complete JDK (with
3639 #     javac) and not a JRE, etc.
3640 #
3641 # **) On Windows we typically use a well-known path.
3642 #     On MacOSX we typically use the tool java_home.
3643 #     On Linux we typically find javac in the $PATH, and then follow a
3644 #     chain of symlinks that often ends up in a real JDK.
3645 #
3646 # This leads to the code where we check in different ways to locate a
3647 # JDK, and if one is found, check if it is acceptable. If not, we print
3648 # our reasons for rejecting it (useful when debugging non-working
3649 # configure situations) and continue checking the next one.
3650 ########################################################################
3651 
3652 # Execute the check given as argument, and verify the result
3653 # If the Boot JDK was previously found, do nothing
3654 # $1 A command line (typically autoconf macro) to execute
3655 
3656 
3657 # Test: Is bootjdk explicitely set by command line arguments?
3658 
3659 
3660 # Test: Is $JAVA_HOME set?
3661 
3662 
3663 # Test: Is there a java or javac in the PATH, which is a symlink to the JDK?
3664 
3665 
3666 # Test: Is there a /usr/libexec/java_home? (Typically on MacOSX)
3667 # $1: Argument to the java_home binary (optional)
3668 
3669 
3670 # Test: On MacOS X, can we find a boot jdk using /usr/libexec/java_home?
3671 
3672 
3673 # Look for a jdk in the given path. If there are multiple, try to select the newest.
3674 # If found, set BOOT_JDK and BOOT_JDK_FOUND.
3675 # $1 = Path to directory containing jdk installations.
3676 # $2 = String to append to the found JDK directory to get the proper JDK home
3677 
3678 
3679 # Call BOOTJDK_FIND_BEST_JDK_IN_DIRECTORY, but use the given
3680 # environmental variable as base for where to look.
3681 # $1 Name of an environmal variable, assumed to point to the Program Files directory.
3682 
3683 
3684 # Test: Is there a JDK installed in default, well-known locations?
3685 
3686 
3687 # Check that a command-line tool in the Boot JDK is correct
3688 # $1 = name of variable to assign
3689 # $2 = name of binary
3690 
3691 
3692 ###############################################################################
3693 #
3694 # We need a Boot JDK to bootstrap the build.
3695 #
3696 
3697 
3698 
3699 
3700 
3701 #
3702 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
3703 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3704 #
3705 # This code is free software; you can redistribute it and/or modify it
3706 # under the terms of the GNU General Public License version 2 only, as
3707 # published by the Free Software Foundation.  Oracle designates this
3708 # particular file as subject to the "Classpath" exception as provided
3709 # by Oracle in the LICENSE file that accompanied this code.
3710 #
3711 # This code is distributed in the hope that it will be useful, but WITHOUT
3712 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3713 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3714 # version 2 for more details (a copy is included in the LICENSE file that
3715 # accompanied this code).
3716 #
3717 # You should have received a copy of the GNU General Public License version
3718 # 2 along with this work; if not, write to the Free Software Foundation,
3719 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3720 #
3721 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3722 # or visit www.oracle.com if you need additional information or have any
3723 # questions.
3724 #
3725 
3726 
3727 
3728 
3729 
3730 
3731 
3732 
3733 
3734 
3735 
3736 
3737 
3738 
3739 
3740 ################################################################################
3741 #
3742 # Optionally enable distributed compilation of native code using icecc/icecream
3743 #
3744 
3745 
3746 
3747 
3748 
3749 
3750 
3751 #
3752 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
3753 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3754 #
3755 # This code is free software; you can redistribute it and/or modify it
3756 # under the terms of the GNU General Public License version 2 only, as
3757 # published by the Free Software Foundation.  Oracle designates this
3758 # particular file as subject to the "Classpath" exception as provided
3759 # by Oracle in the LICENSE file that accompanied this code.
3760 #
3761 # This code is distributed in the hope that it will be useful, but WITHOUT
3762 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3763 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3764 # version 2 for more details (a copy is included in the LICENSE file that
3765 # accompanied this code).
3766 #
3767 # You should have received a copy of the GNU General Public License version
3768 # 2 along with this work; if not, write to the Free Software Foundation,
3769 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3770 #
3771 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3772 # or visit www.oracle.com if you need additional information or have any
3773 # questions.
3774 #
3775 
3776 # Reset the global CFLAGS/LDFLAGS variables and initialize them with the
3777 # corresponding configure arguments instead
3778 
3779 
3780 # Setup the sysroot flags and add them to global CFLAGS and LDFLAGS so
3781 # that configure can use them while detecting compilers.
3782 # TOOLCHAIN_TYPE is available here.
3783 # Param 1 - Optional prefix to all variables. (e.g BUILD_)
3784 
3785 
3786 
3787 
3788 
3789 
3790 # Documentation on common flags used for solstudio in HIGHEST.
3791 #
3792 # WARNING: Use of OPTIMIZATION_LEVEL=HIGHEST in your Makefile needs to be
3793 #          done with care, there are some assumptions below that need to
3794 #          be understood about the use of pointers, and IEEE behavior.
3795 #
3796 # -fns: Use non-standard floating point mode (not IEEE 754)
3797 # -fsimple: Do some simplification of floating point arithmetic (not IEEE 754)
3798 # -fsingle: Use single precision floating point with 'float'
3799 # -xalias_level=basic: Assume memory references via basic pointer types do not alias
3800 #   (Source with excessing pointer casting and data access with mixed
3801 #    pointer types are not recommended)
3802 # -xbuiltin=%all: Use intrinsic or inline versions for math/std functions
3803 #   (If you expect perfect errno behavior, do not use this)
3804 # -xdepend: Loop data dependency optimizations (need -xO3 or higher)
3805 # -xrestrict: Pointer parameters to functions do not overlap
3806 #   (Similar to -xalias_level=basic usage, but less obvious sometimes.
3807 #    If you pass in multiple pointers to the same data, do not use this)
3808 # -xlibmil: Inline some library routines
3809 #   (If you expect perfect errno behavior, do not use this)
3810 # -xlibmopt: Use optimized math routines (CURRENTLY DISABLED)
3811 #   (If you expect perfect errno behavior, do not use this)
3812 #  Can cause undefined external on Solaris 8 X86 on __sincos, removing for now
3813 
3814     # FIXME: this will never happen since sparc != sparcv9, ie 32 bit, which we don't build anymore.
3815     # Bug?
3816     #if test "x$OPENJDK_TARGET_CPU" = xsparc; then
3817     #  CFLAGS_JDK="${CFLAGS_JDK} -xmemalign=4s"
3818     #  CXXFLAGS_JDK="${CXXFLAGS_JDK} -xmemalign=4s"
3819     #fi
3820 
3821 
3822 
3823 
3824 
3825 # FLAGS_COMPILER_CHECK_ARGUMENTS([ARGUMENT], [RUN-IF-TRUE],
3826 #                                   [RUN-IF-FALSE])
3827 # ------------------------------------------------------------
3828 # Check that the c and c++ compilers support an argument
3829 
3830 
3831 # FLAGS_LINKER_CHECK_ARGUMENTS([ARGUMENT], [RUN-IF-TRUE],
3832 #                                    [RUN-IF-FALSE])
3833 # ------------------------------------------------------------
3834 # Check that the linker support an argument
3835 
3836 
3837 
3838 
3839 #
3840 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
3841 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3842 #
3843 # This code is free software; you can redistribute it and/or modify it
3844 # under the terms of the GNU General Public License version 2 only, as
3845 # published by the Free Software Foundation.  Oracle designates this
3846 # particular file as subject to the "Classpath" exception as provided
3847 # by Oracle in the LICENSE file that accompanied this code.
3848 #
3849 # This code is distributed in the hope that it will be useful, but WITHOUT
3850 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3851 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3852 # version 2 for more details (a copy is included in the LICENSE file that
3853 # accompanied this code).
3854 #
3855 # You should have received a copy of the GNU General Public License version
3856 # 2 along with this work; if not, write to the Free Software Foundation,
3857 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3858 #
3859 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3860 # or visit www.oracle.com if you need additional information or have any
3861 # questions.
3862 #
3863 
3864 
3865 
3866 
3867 
3868 cygwin_help() {
3869   case $1 in
3870     unzip)
3871       PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P unzip )"
3872       HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
3873       ;;
3874     zip)
3875       PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P zip )"
3876       HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
3877       ;;
3878     make)
3879       PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P make )"
3880       HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
3881       ;;
3882     freetype)
3883       HELP_MSG="
3884 The freetype library can now be build during the configure process.
3885 Download the freetype sources and unpack them into an arbitrary directory:
3886 
3887 wget http://download.savannah.gnu.org/releases/freetype/freetype-2.5.3.tar.gz
3888 tar -xzf freetype-2.5.3.tar.gz
3889 
3890 Then run configure with '--with-freetype-src=<freetype_src>'. This will
3891 automatically build the freetype library into '<freetype_src>/lib64' for 64-bit
3892 builds or into '<freetype_src>/lib32' for 32-bit builds.
3893 Afterwards you can always use '--with-freetype-include=<freetype_src>/include'
3894 and '--with-freetype-lib=<freetype_src>/lib32|64' for other builds."
3895       ;;
3896   esac
3897 }
3898 
3899 msys_help() {
3900   PKGHANDLER_COMMAND=""
3901 }
3902 
3903 apt_help() {
3904   case $1 in
3905     reduced)
3906       PKGHANDLER_COMMAND="sudo apt-get install gcc-multilib g++-multilib" ;;
3907     devkit)
3908       PKGHANDLER_COMMAND="sudo apt-get install build-essential" ;;
3909     openjdk)
3910       PKGHANDLER_COMMAND="sudo apt-get install openjdk-7-jdk" ;;
3911     alsa)
3912       PKGHANDLER_COMMAND="sudo apt-get install libasound2-dev" ;;
3913     cups)
3914       PKGHANDLER_COMMAND="sudo apt-get install libcups2-dev" ;;
3915     freetype)
3916       PKGHANDLER_COMMAND="sudo apt-get install libfreetype6-dev" ;;
3917     ffi)
3918       PKGHANDLER_COMMAND="sudo apt-get install libffi-dev" ;;
3919     x11)
3920       PKGHANDLER_COMMAND="sudo apt-get install libX11-dev libxext-dev libxrender-dev libxtst-dev libxt-dev" ;;
3921     ccache)
3922       PKGHANDLER_COMMAND="sudo apt-get install ccache" ;;
3923   esac
3924 }
3925 
3926 yum_help() {
3927   case $1 in
3928     devkit)
3929       PKGHANDLER_COMMAND="sudo yum groupinstall \"Development Tools\"" ;;
3930     openjdk)
3931       PKGHANDLER_COMMAND="sudo yum install java-1.7.0-openjdk" ;;
3932     alsa)
3933       PKGHANDLER_COMMAND="sudo yum install alsa-lib-devel" ;;
3934     cups)
3935       PKGHANDLER_COMMAND="sudo yum install cups-devel" ;;
3936     freetype)
3937       PKGHANDLER_COMMAND="sudo yum install freetype-devel" ;;
3938     x11)
3939       PKGHANDLER_COMMAND="sudo yum install libXtst-devel libXt-devel libXrender-devel libXi-devel" ;;
3940     ccache)
3941       PKGHANDLER_COMMAND="sudo yum install ccache" ;;
3942   esac
3943 }
3944 
3945 port_help() {
3946   PKGHANDLER_COMMAND=""
3947 }
3948 
3949 pkgutil_help() {
3950   PKGHANDLER_COMMAND=""
3951 }
3952 
3953 pkgadd_help() {
3954   PKGHANDLER_COMMAND=""
3955 }
3956 
3957 # This function will check if we're called from the "configure" wrapper while
3958 # printing --help. If so, we will print out additional information that can
3959 # only be extracted within the autoconf script, and then exit. This must be
3960 # called at the very beginning in configure.ac.
3961 
3962 
3963 
3964 
3965 
3966 
3967 #
3968 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
3969 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3970 #
3971 # This code is free software; you can redistribute it and/or modify it
3972 # under the terms of the GNU General Public License version 2 only, as
3973 # published by the Free Software Foundation.  Oracle designates this
3974 # particular file as subject to the "Classpath" exception as provided
3975 # by Oracle in the LICENSE file that accompanied this code.
3976 #
3977 # This code is distributed in the hope that it will be useful, but WITHOUT
3978 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3979 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3980 # version 2 for more details (a copy is included in the LICENSE file that
3981 # accompanied this code).
3982 #
3983 # You should have received a copy of the GNU General Public License version
3984 # 2 along with this work; if not, write to the Free Software Foundation,
3985 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3986 #
3987 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3988 # or visit www.oracle.com if you need additional information or have any
3989 # questions.
3990 #
3991 
3992 
3993 
3994 
3995 
3996 
3997 
3998 
3999 
4000 
4001 ###############################################################################
4002 #
4003 # Should we build only OpenJDK even if closed sources are present?
4004 #
4005 
4006 
4007 
4008 
4009 ###############################################################################
4010 #
4011 # Setup version numbers
4012 #
4013 
4014 
4015 
4016 
4017 
4018 
4019 ################################################################################
4020 #
4021 # Gcov coverage data for hotspot
4022 #
4023 
4024 
4025 ################################################################################
4026 #
4027 # Static build support.  When enabled will generate static
4028 # libraries instead of shared libraries for all JDK libs.
4029 #
4030 
4031 
4032 
4033 
4034 #
4035 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
4036 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4037 #
4038 # This code is free software; you can redistribute it and/or modify it
4039 # under the terms of the GNU General Public License version 2 only, as
4040 # published by the Free Software Foundation.  Oracle designates this
4041 # particular file as subject to the "Classpath" exception as provided
4042 # by Oracle in the LICENSE file that accompanied this code.
4043 #
4044 # This code is distributed in the hope that it will be useful, but WITHOUT
4045 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4046 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4047 # version 2 for more details (a copy is included in the LICENSE file that
4048 # accompanied this code).
4049 #
4050 # You should have received a copy of the GNU General Public License version
4051 # 2 along with this work; if not, write to the Free Software Foundation,
4052 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4053 #
4054 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4055 # or visit www.oracle.com if you need additional information or have any
4056 # questions.
4057 #
4058 
4059 # Major library component reside in separate files.
4060 #
4061 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
4062 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4063 #
4064 # This code is free software; you can redistribute it and/or modify it
4065 # under the terms of the GNU General Public License version 2 only, as
4066 # published by the Free Software Foundation.  Oracle designates this
4067 # particular file as subject to the "Classpath" exception as provided
4068 # by Oracle in the LICENSE file that accompanied this code.
4069 #
4070 # This code is distributed in the hope that it will be useful, but WITHOUT
4071 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4072 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4073 # version 2 for more details (a copy is included in the LICENSE file that
4074 # accompanied this code).
4075 #
4076 # You should have received a copy of the GNU General Public License version
4077 # 2 along with this work; if not, write to the Free Software Foundation,
4078 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4079 #
4080 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4081 # or visit www.oracle.com if you need additional information or have any
4082 # questions.
4083 #
4084 
4085 ################################################################################
4086 # Setup alsa (Advanced Linux Sound Architecture)
4087 ################################################################################
4088 
4089 
4090 #
4091 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
4092 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4093 #
4094 # This code is free software; you can redistribute it and/or modify it
4095 # under the terms of the GNU General Public License version 2 only, as
4096 # published by the Free Software Foundation.  Oracle designates this
4097 # particular file as subject to the "Classpath" exception as provided
4098 # by Oracle in the LICENSE file that accompanied this code.
4099 #
4100 # This code is distributed in the hope that it will be useful, but WITHOUT
4101 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4102 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4103 # version 2 for more details (a copy is included in the LICENSE file that
4104 # accompanied this code).
4105 #
4106 # You should have received a copy of the GNU General Public License version
4107 # 2 along with this work; if not, write to the Free Software Foundation,
4108 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4109 #
4110 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4111 # or visit www.oracle.com if you need additional information or have any
4112 # questions.
4113 #
4114 
4115 ################################################################################
4116 # Setup bundled libraries.
4117 #
4118 # For libjpeg, giflib, libpng, lcms2 and zlib, the source is present in the
4119 # OpenJDK repository. Default is to use these libraries as bundled, but they
4120 # might be replaced by en external version by the user.
4121 ################################################################################
4122 
4123 
4124 ################################################################################
4125 # Setup libjpeg
4126 ################################################################################
4127 
4128 
4129 ################################################################################
4130 # Setup giflib
4131 ################################################################################
4132 
4133 
4134 ################################################################################
4135 # Setup libpng
4136 ################################################################################
4137 
4138 
4139 ################################################################################
4140 # Setup zlib
4141 ################################################################################
4142 
4143 
4144 ################################################################################
4145 # Setup lcms (Little CMS)
4146 ################################################################################
4147 
4148 
4149 #
4150 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
4151 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4152 #
4153 # This code is free software; you can redistribute it and/or modify it
4154 # under the terms of the GNU General Public License version 2 only, as
4155 # published by the Free Software Foundation.  Oracle designates this
4156 # particular file as subject to the "Classpath" exception as provided
4157 # by Oracle in the LICENSE file that accompanied this code.
4158 #
4159 # This code is distributed in the hope that it will be useful, but WITHOUT
4160 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4161 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4162 # version 2 for more details (a copy is included in the LICENSE file that
4163 # accompanied this code).
4164 #
4165 # You should have received a copy of the GNU General Public License version
4166 # 2 along with this work; if not, write to the Free Software Foundation,
4167 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4168 #
4169 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4170 # or visit www.oracle.com if you need additional information or have any
4171 # questions.
4172 #
4173 
4174 ################################################################################
4175 # Setup cups (Common Unix Printing System)
4176 ################################################################################
4177 
4178 
4179 #
4180 # Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
4181 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4182 #
4183 # This code is free software; you can redistribute it and/or modify it
4184 # under the terms of the GNU General Public License version 2 only, as
4185 # published by the Free Software Foundation.  Oracle designates this
4186 # particular file as subject to the "Classpath" exception as provided
4187 # by Oracle in the LICENSE file that accompanied this code.
4188 #
4189 # This code is distributed in the hope that it will be useful, but WITHOUT
4190 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4191 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4192 # version 2 for more details (a copy is included in the LICENSE file that
4193 # accompanied this code).
4194 #
4195 # You should have received a copy of the GNU General Public License version
4196 # 2 along with this work; if not, write to the Free Software Foundation,
4197 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4198 #
4199 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4200 # or visit www.oracle.com if you need additional information or have any
4201 # questions.
4202 #
4203 
4204 ################################################################################
4205 # Setup libffi (Foreign Function Interface)
4206 ################################################################################
4207 
4208 
4209 #
4210 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
4211 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4212 #
4213 # This code is free software; you can redistribute it and/or modify it
4214 # under the terms of the GNU General Public License version 2 only, as
4215 # published by the Free Software Foundation.  Oracle designates this
4216 # particular file as subject to the "Classpath" exception as provided
4217 # by Oracle in the LICENSE file that accompanied this code.
4218 #
4219 # This code is distributed in the hope that it will be useful, but WITHOUT
4220 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4221 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4222 # version 2 for more details (a copy is included in the LICENSE file that
4223 # accompanied this code).
4224 #
4225 # You should have received a copy of the GNU General Public License version
4226 # 2 along with this work; if not, write to the Free Software Foundation,
4227 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4228 #
4229 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4230 # or visit www.oracle.com if you need additional information or have any
4231 # questions.
4232 #
4233 
4234 ################################################################################
4235 # Build the freetype lib from source
4236 ################################################################################
4237 
4238 
4239 ################################################################################
4240 # Check if a potential freeype library match is correct and usable
4241 ################################################################################
4242 
4243 
4244 ################################################################################
4245 # Setup freetype (The FreeType2 font rendering library)
4246 ################################################################################
4247 
4248 
4249 #
4250 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
4251 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4252 #
4253 # This code is free software; you can redistribute it and/or modify it
4254 # under the terms of the GNU General Public License version 2 only, as
4255 # published by the Free Software Foundation.  Oracle designates this
4256 # particular file as subject to the "Classpath" exception as provided
4257 # by Oracle in the LICENSE file that accompanied this code.
4258 #
4259 # This code is distributed in the hope that it will be useful, but WITHOUT
4260 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4261 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4262 # version 2 for more details (a copy is included in the LICENSE file that
4263 # accompanied this code).
4264 #
4265 # You should have received a copy of the GNU General Public License version
4266 # 2 along with this work; if not, write to the Free Software Foundation,
4267 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4268 #
4269 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4270 # or visit www.oracle.com if you need additional information or have any
4271 # questions.
4272 #
4273 
4274 ################################################################################
4275 # Setup the standard C/C++ runtime libraries.
4276 #
4277 # Most importantly, determine if stdc++ should be linked statically or
4278 # dynamically.
4279 ################################################################################
4280 
4281 
4282 #
4283 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
4284 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4285 #
4286 # This code is free software; you can redistribute it and/or modify it
4287 # under the terms of the GNU General Public License version 2 only, as
4288 # published by the Free Software Foundation.  Oracle designates this
4289 # particular file as subject to the "Classpath" exception as provided
4290 # by Oracle in the LICENSE file that accompanied this code.
4291 #
4292 # This code is distributed in the hope that it will be useful, but WITHOUT
4293 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4294 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4295 # version 2 for more details (a copy is included in the LICENSE file that
4296 # accompanied this code).
4297 #
4298 # You should have received a copy of the GNU General Public License version
4299 # 2 along with this work; if not, write to the Free Software Foundation,
4300 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4301 #
4302 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4303 # or visit www.oracle.com if you need additional information or have any
4304 # questions.
4305 #
4306 
4307 ################################################################################
4308 # Setup X11 Windows system
4309 ################################################################################
4310 
4311 
4312 
4313 ################################################################################
4314 # Determine which libraries are needed for this configuration
4315 ################################################################################
4316 
4317 
4318 ################################################################################
4319 # Parse library options, and setup needed libraries
4320 ################################################################################
4321 
4322 
4323 ################################################################################
4324 # Setup llvm (Low-Level VM)
4325 ################################################################################
4326 
4327 
4328 ################################################################################
4329 # Setup various libraries, typically small system libraries
4330 ################################################################################
4331 
4332 
4333 #
4334 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
4335 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4336 #
4337 # This code is free software; you can redistribute it and/or modify it
4338 # under the terms of the GNU General Public License version 2 only, as
4339 # published by the Free Software Foundation.  Oracle designates this
4340 # particular file as subject to the "Classpath" exception as provided
4341 # by Oracle in the LICENSE file that accompanied this code.
4342 #
4343 # This code is distributed in the hope that it will be useful, but WITHOUT
4344 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4345 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4346 # version 2 for more details (a copy is included in the LICENSE file that
4347 # accompanied this code).
4348 #
4349 # You should have received a copy of the GNU General Public License version
4350 # 2 along with this work; if not, write to the Free Software Foundation,
4351 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4352 #
4353 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4354 # or visit www.oracle.com if you need additional information or have any
4355 # questions.
4356 #
4357 
4358 # Support macro for PLATFORM_EXTRACT_TARGET_AND_BUILD.
4359 # Converts autoconf style CPU name to OpenJDK style, into
4360 # VAR_CPU, VAR_CPU_ARCH, VAR_CPU_BITS and VAR_CPU_ENDIAN.
4361 
4362 
4363 # Support macro for PLATFORM_EXTRACT_TARGET_AND_BUILD.
4364 # Converts autoconf style OS name to OpenJDK style, into
4365 # VAR_OS, VAR_OS_TYPE and VAR_OS_ENV.
4366 
4367 
4368 # Expects $host_os $host_cpu $build_os and $build_cpu
4369 # and $with_target_bits to have been setup!
4370 #
4371 # Translate the standard triplet(quadruplet) definition
4372 # of the target/build system into OPENJDK_TARGET_OS, OPENJDK_TARGET_CPU,
4373 # OPENJDK_BUILD_OS, etc.
4374 
4375 
4376 # Check if a reduced build (32-bit on 64-bit platforms) is requested, and modify behaviour
4377 # accordingly. Must be done after setting up build and target system, but before
4378 # doing anything else with these values.
4379 
4380 
4381 # Setup the legacy variables, for controlling the old makefiles.
4382 #
4383 
4384 
4385 
4386 
4387 #%%% Build and target systems %%%
4388 
4389 
4390 
4391 
4392 # Support macro for PLATFORM_SETUP_OPENJDK_TARGET_BITS.
4393 # Add -mX to various FLAGS variables.
4394 
4395 
4396 
4397 
4398 
4399 
4400 #
4401 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
4402 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4403 #
4404 # This code is free software; you can redistribute it and/or modify it
4405 # under the terms of the GNU General Public License version 2 only, as
4406 # published by the Free Software Foundation.  Oracle designates this
4407 # particular file as subject to the "Classpath" exception as provided
4408 # by Oracle in the LICENSE file that accompanied this code.
4409 #
4410 # This code is distributed in the hope that it will be useful, but WITHOUT
4411 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4412 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4413 # version 2 for more details (a copy is included in the LICENSE file that
4414 # accompanied this code).
4415 #
4416 # You should have received a copy of the GNU General Public License version
4417 # 2 along with this work; if not, write to the Free Software Foundation,
4418 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4419 #
4420 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4421 # or visit www.oracle.com if you need additional information or have any
4422 # questions.
4423 #
4424 
4425 
4426 
4427 
4428 
4429 
4430 
4431 #
4432 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
4433 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4434 #
4435 # This code is free software; you can redistribute it and/or modify it
4436 # under the terms of the GNU General Public License version 2 only, as
4437 # published by the Free Software Foundation.  Oracle designates this
4438 # particular file as subject to the "Classpath" exception as provided
4439 # by Oracle in the LICENSE file that accompanied this code.
4440 #
4441 # This code is distributed in the hope that it will be useful, but WITHOUT
4442 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4443 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4444 # version 2 for more details (a copy is included in the LICENSE file that
4445 # accompanied this code).
4446 #
4447 # You should have received a copy of the GNU General Public License version
4448 # 2 along with this work; if not, write to the Free Software Foundation,
4449 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4450 #
4451 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4452 # or visit www.oracle.com if you need additional information or have any
4453 # questions.
4454 #
4455 
4456 ########################################################################
4457 # This file is responsible for detecting, verifying and setting up the
4458 # toolchain, i.e. the compiler, linker and related utilities. It will setup
4459 # proper paths to the binaries, but it will not setup any flags.
4460 #
4461 # The binaries used is determined by the toolchain type, which is the family of
4462 # compilers and related tools that are used.
4463 ########################################################################
4464 
4465 
4466 # All valid toolchains, regardless of platform (used by help.m4)
4467 VALID_TOOLCHAINS_all="gcc clang solstudio xlc microsoft"
4468 
4469 # These toolchains are valid on different platforms
4470 VALID_TOOLCHAINS_linux="gcc clang"
4471 VALID_TOOLCHAINS_solaris="solstudio"
4472 VALID_TOOLCHAINS_macosx="gcc clang"
4473 VALID_TOOLCHAINS_aix="xlc"
4474 VALID_TOOLCHAINS_windows="microsoft"
4475 
4476 # Toolchain descriptions
4477 TOOLCHAIN_DESCRIPTION_clang="clang/LLVM"
4478 TOOLCHAIN_DESCRIPTION_gcc="GNU Compiler Collection"
4479 TOOLCHAIN_DESCRIPTION_microsoft="Microsoft Visual Studio"
4480 TOOLCHAIN_DESCRIPTION_solstudio="Oracle Solaris Studio"
4481 TOOLCHAIN_DESCRIPTION_xlc="IBM XL C/C++"
4482 
4483 # Setup a number of variables describing how native output files are
4484 # named on this platform/toolchain.
4485 
4486 
4487 # Determine which toolchain type to use, and make sure it is valid for this
4488 # platform. Setup various information about the selected toolchain.
4489 
4490 
4491 # Before we start detecting the toolchain executables, we might need some
4492 # special setup, e.g. additional paths etc.
4493 
4494 
4495 # Restore path, etc
4496 
4497 
4498 # Check if a compiler is of the toolchain type we expect, and save the version
4499 # information from it. If the compiler does not match the expected type,
4500 # this function will abort using AC_MSG_ERROR. If it matches, the version will
4501 # be stored in CC_VERSION_NUMBER/CXX_VERSION_NUMBER (as a dotted number), and
4502 # the full version string in CC_VERSION_STRING/CXX_VERSION_STRING.
4503 #
4504 # $1 = compiler to test (CC or CXX)
4505 # $2 = human readable name of compiler (C or C++)
4506 
4507 
4508 # Try to locate the given C or C++ compiler in the path, or otherwise.
4509 #
4510 # $1 = compiler to test (CC or CXX)
4511 # $2 = human readable name of compiler (C or C++)
4512 # $3 = list of compiler names to search for
4513 
4514 
4515 # Detect the core components of the toolchain, i.e. the compilers (CC and CXX),
4516 # preprocessor (CPP and CXXCPP), the linker (LD), the assembler (AS) and the
4517 # archiver (AR). Verify that the compilers are correct according to the
4518 # toolchain type.
4519 
4520 
4521 # Setup additional tools that is considered a part of the toolchain, but not the
4522 # core part. Many of these are highly platform-specific and do not exist,
4523 # and/or are not needed on all platforms.
4524 
4525 
4526 # Setup the build tools (i.e, the compiler and linker used to build programs
4527 # that should be run on the build platform, not the target platform, as a build
4528 # helper). Since the non-cross-compile case uses the normal, target compilers
4529 # for this, we can only do this after these have been setup.
4530 
4531 
4532 # Setup legacy variables that are still needed as alternative ways to refer to
4533 # parts of the toolchain.
4534 
4535 
4536 # Do some additional checks on the detected tools.
4537 
4538 
4539 # Setup the JTReg Regression Test Harness.
4540 
4541 
4542 #
4543 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
4544 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4545 #
4546 # This code is free software; you can redistribute it and/or modify it
4547 # under the terms of the GNU General Public License version 2 only, as
4548 # published by the Free Software Foundation.  Oracle designates this
4549 # particular file as subject to the "Classpath" exception as provided
4550 # by Oracle in the LICENSE file that accompanied this code.
4551 #
4552 # This code is distributed in the hope that it will be useful, but WITHOUT
4553 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4554 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4555 # version 2 for more details (a copy is included in the LICENSE file that
4556 # accompanied this code).
4557 #
4558 # You should have received a copy of the GNU General Public License version
4559 # 2 along with this work; if not, write to the Free Software Foundation,
4560 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4561 #
4562 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4563 # or visit www.oracle.com if you need additional information or have any
4564 # questions.
4565 #
4566 
4567 ################################################################################
4568 # The order of these defines the priority by which we try to find them.
4569 VALID_VS_VERSIONS="2013 2012 2010"
4570 
4571 VS_DESCRIPTION_2010="Microsoft Visual Studio 2010"
4572 VS_VERSION_INTERNAL_2010=100
4573 VS_MSVCR_2010=msvcr100.dll
4574 # We don't use msvcp on Visual Studio 2010
4575 #VS_MSVCP_2010=msvcp100.dll
4576 VS_ENVVAR_2010="VS100COMNTOOLS"
4577 VS_VS_INSTALLDIR_2010="Microsoft Visual Studio 10.0"
4578 VS_SDK_INSTALLDIR_2010="Microsoft SDKs/Windows/v7.1"
4579 VS_VS_PLATFORM_NAME_2010="v100"
4580 VS_SDK_PLATFORM_NAME_2010="Windows7.1SDK"
4581 
4582 VS_DESCRIPTION_2012="Microsoft Visual Studio 2012"
4583 VS_VERSION_INTERNAL_2012=110
4584 VS_MSVCR_2012=msvcr110.dll
4585 VS_MSVCP_2012=msvcp110.dll
4586 VS_ENVVAR_2012="VS110COMNTOOLS"
4587 VS_VS_INSTALLDIR_2012="Microsoft Visual Studio 11.0"
4588 VS_SDK_INSTALLDIR_2012=
4589 VS_VS_PLATFORM_NAME_2012="v110"
4590 VS_SDK_PLATFORM_NAME_2012=
4591 
4592 VS_DESCRIPTION_2013="Microsoft Visual Studio 2013"
4593 VS_VERSION_INTERNAL_2013=120
4594 VS_MSVCR_2013=msvcr120.dll
4595 VS_MSVCP_2013=msvcp120.dll
4596 VS_ENVVAR_2013="VS120COMNTOOLS"
4597 VS_VS_INSTALLDIR_2013="Microsoft Visual Studio 12.0"
4598 VS_SDK_INSTALLDIR_2013=
4599 VS_VS_PLATFORM_NAME_2013="v120"
4600 VS_SDK_PLATFORM_NAME_2013=
4601 
4602 ################################################################################
4603 
4604 
4605 
4606 ################################################################################
4607 
4608 
4609 
4610 ################################################################################
4611 # Finds the bat or cmd file in Visual Studio or the SDK that sets up a proper
4612 # build environment and assigns it to VS_ENV_CMD
4613 
4614 
4615 ################################################################################
4616 
4617 
4618 
4619 ################################################################################
4620 # Check if the VS env variables were setup prior to running configure.
4621 # If not, then find vcvarsall.bat and run it automatically, and integrate
4622 # the set env variables into the spec file.
4623 
4624 
4625 
4626 
4627 
4628 
4629 
4630 
4631 
4632 
4633 
4634 
4635 
4636 
4637 # This line needs to be here, verbatim, after all includes and the dummy hook
4638 # definitions. It is replaced with custom functionality when building
4639 # custom sources.
4640 #CUSTOM_AUTOCONF_INCLUDE
4641 
4642 # Do not change or remove the following line, it is needed for consistency checks:
4643 DATE_WHEN_GENERATED=1448463381
4644 
4645 ###############################################################################
4646 #
4647 # Initialization / Boot-strapping
4648 #
4649 # The bootstrapping process needs to solve the "chicken or the egg" problem,
4650 # thus it jumps back and forth, each time gaining something needed later on.
4651 #
4652 ###############################################################################
4653 
4654 # If we are requested to print additional help, do that and then exit.
4655 # This must be the very first call.
4656 
4657   if test "x$CONFIGURE_PRINT_TOOLCHAIN_LIST" != x; then
4658     $PRINTF "The following toolchains are available as arguments to --with-toolchain-type.\n"
4659     $PRINTF "Which are valid to use depends on the build platform.\n"
4660     for toolchain in $VALID_TOOLCHAINS_all; do
4661       # Use indirect variable referencing
4662       toolchain_var_name=TOOLCHAIN_DESCRIPTION_$toolchain
4663       TOOLCHAIN_DESCRIPTION=${!toolchain_var_name}
4664       $PRINTF "  %-10s  %s\n" $toolchain "$TOOLCHAIN_DESCRIPTION"
4665     done
4666 
4667     # And now exit directly
4668     exit 0
4669   fi
4670 
4671 
4672 # Basic initialization that must happen first of all in the normal process.
4673 
4674   # Save the original command line. This is passed to us by the wrapper configure script.
4675 
4676   # Save the path variable before it gets changed
4677   ORIGINAL_PATH="$PATH"
4678 
4679   DATE_WHEN_CONFIGURED=`LANG=C date`
4680 
4681   { $as_echo "$as_me:${as_lineno-$LINENO}: Configuration created at $DATE_WHEN_CONFIGURED." >&5
4682 $as_echo "$as_me: Configuration created at $DATE_WHEN_CONFIGURED." >&6;}
4683   { $as_echo "$as_me:${as_lineno-$LINENO}: configure script generated at timestamp $DATE_WHEN_GENERATED." >&5
4684 $as_echo "$as_me: configure script generated at timestamp $DATE_WHEN_GENERATED." >&6;}
4685 
4686 
4687   # Start with tools that do not need have cross compilation support
4688   # and can be expected to be found in the default PATH. These tools are
4689   # used by configure.
4690 
4691   # First are all the simple required tools.
4692 
4693 
4694 
4695   # Publish this variable in the help.
4696 
4697 
4698   if [ -z "${BASENAME+x}" ]; then
4699     # The variable is not set by user, try to locate tool using the code snippet
4700     for ac_prog in basename
4701 do
4702   # Extract the first word of "$ac_prog", so it can be a program name with args.
4703 set dummy $ac_prog; ac_word=$2
4704 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4705 $as_echo_n "checking for $ac_word... " >&6; }
4706 if ${ac_cv_path_BASENAME+:} false; then :
4707   $as_echo_n "(cached) " >&6
4708 else
4709   case $BASENAME in
4710   [\\/]* | ?:[\\/]*)
4711   ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
4712   ;;
4713   *)
4714   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4715 for as_dir in $PATH
4716 do
4717   IFS=$as_save_IFS
4718   test -z "$as_dir" && as_dir=.
4719     for ac_exec_ext in '' $ac_executable_extensions; do
4720   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4721     ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
4722     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4723     break 2
4724   fi
4725 done
4726   done
4727 IFS=$as_save_IFS
4728 
4729   ;;
4730 esac
4731 fi
4732 BASENAME=$ac_cv_path_BASENAME
4733 if test -n "$BASENAME"; then
4734   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
4735 $as_echo "$BASENAME" >&6; }
4736 else
4737   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4738 $as_echo "no" >&6; }
4739 fi
4740 
4741 
4742   test -n "$BASENAME" && break
4743 done
4744 
4745   else
4746     # The variable is set, but is it from the command line or the environment?
4747 
4748     # Try to remove the string !BASENAME! from our list.
4749     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BASENAME!/}
4750     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
4751       # If it failed, the variable was not from the command line. Ignore it,
4752       # but warn the user (except for BASH, which is always set by the calling BASH).
4753       if test "xBASENAME" != xBASH; then
4754         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BASENAME from the environment. Use command line variables instead." >&5
4755 $as_echo "$as_me: WARNING: Ignoring value of BASENAME from the environment. Use command line variables instead." >&2;}
4756       fi
4757       # Try to locate tool using the code snippet
4758       for ac_prog in basename
4759 do
4760   # Extract the first word of "$ac_prog", so it can be a program name with args.
4761 set dummy $ac_prog; ac_word=$2
4762 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4763 $as_echo_n "checking for $ac_word... " >&6; }
4764 if ${ac_cv_path_BASENAME+:} false; then :
4765   $as_echo_n "(cached) " >&6
4766 else
4767   case $BASENAME in
4768   [\\/]* | ?:[\\/]*)
4769   ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
4770   ;;
4771   *)
4772   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4773 for as_dir in $PATH
4774 do
4775   IFS=$as_save_IFS
4776   test -z "$as_dir" && as_dir=.
4777     for ac_exec_ext in '' $ac_executable_extensions; do
4778   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4779     ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
4780     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4781     break 2
4782   fi
4783 done
4784   done
4785 IFS=$as_save_IFS
4786 
4787   ;;
4788 esac
4789 fi
4790 BASENAME=$ac_cv_path_BASENAME
4791 if test -n "$BASENAME"; then
4792   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
4793 $as_echo "$BASENAME" >&6; }
4794 else
4795   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4796 $as_echo "no" >&6; }
4797 fi
4798 
4799 
4800   test -n "$BASENAME" && break
4801 done
4802 
4803     else
4804       # If it succeeded, then it was overridden by the user. We will use it
4805       # for the tool.
4806 
4807       # First remove it from the list of overridden variables, so we can test
4808       # for unknown variables in the end.
4809       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
4810 
4811       # Check if we try to supply an empty value
4812       if test "x$BASENAME" = x; then
4813         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool BASENAME= (no value)" >&5
4814 $as_echo "$as_me: Setting user supplied tool BASENAME= (no value)" >&6;}
4815         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASENAME" >&5
4816 $as_echo_n "checking for BASENAME... " >&6; }
4817         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
4818 $as_echo "disabled" >&6; }
4819       else
4820         # Check if the provided tool contains a complete path.
4821         tool_specified="$BASENAME"
4822         tool_basename="${tool_specified##*/}"
4823         if test "x$tool_basename" = "x$tool_specified"; then
4824           # A command without a complete path is provided, search $PATH.
4825           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BASENAME=$tool_basename" >&5
4826 $as_echo "$as_me: Will search for user supplied tool BASENAME=$tool_basename" >&6;}
4827           # Extract the first word of "$tool_basename", so it can be a program name with args.
4828 set dummy $tool_basename; ac_word=$2
4829 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4830 $as_echo_n "checking for $ac_word... " >&6; }
4831 if ${ac_cv_path_BASENAME+:} false; then :
4832   $as_echo_n "(cached) " >&6
4833 else
4834   case $BASENAME in
4835   [\\/]* | ?:[\\/]*)
4836   ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
4837   ;;
4838   *)
4839   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4840 for as_dir in $PATH
4841 do
4842   IFS=$as_save_IFS
4843   test -z "$as_dir" && as_dir=.
4844     for ac_exec_ext in '' $ac_executable_extensions; do
4845   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4846     ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
4847     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4848     break 2
4849   fi
4850 done
4851   done
4852 IFS=$as_save_IFS
4853 
4854   ;;
4855 esac
4856 fi
4857 BASENAME=$ac_cv_path_BASENAME
4858 if test -n "$BASENAME"; then
4859   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
4860 $as_echo "$BASENAME" >&6; }
4861 else
4862   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4863 $as_echo "no" >&6; }
4864 fi
4865 
4866 
4867           if test "x$BASENAME" = x; then
4868             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
4869           fi
4870         else
4871           # Otherwise we believe it is a complete path. Use it as it is.
4872           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BASENAME=$tool_specified" >&5
4873 $as_echo "$as_me: Will use user supplied tool BASENAME=$tool_specified" >&6;}
4874           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASENAME" >&5
4875 $as_echo_n "checking for BASENAME... " >&6; }
4876           if test ! -x "$tool_specified"; then
4877             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
4878 $as_echo "not found" >&6; }
4879             as_fn_error $? "User supplied tool BASENAME=$tool_specified does not exist or is not executable" "$LINENO" 5
4880           fi
4881           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
4882 $as_echo "$tool_specified" >&6; }
4883         fi
4884       fi
4885     fi
4886 
4887   fi
4888 
4889 
4890 
4891   if test "x$BASENAME" = x; then
4892     as_fn_error $? "Could not find required tool for BASENAME" "$LINENO" 5
4893   fi
4894 
4895 
4896 
4897 
4898 
4899   # Publish this variable in the help.
4900 
4901 
4902   if [ -z "${BASH+x}" ]; then
4903     # The variable is not set by user, try to locate tool using the code snippet
4904     for ac_prog in bash
4905 do
4906   # Extract the first word of "$ac_prog", so it can be a program name with args.
4907 set dummy $ac_prog; ac_word=$2
4908 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4909 $as_echo_n "checking for $ac_word... " >&6; }
4910 if ${ac_cv_path_BASH+:} false; then :
4911   $as_echo_n "(cached) " >&6
4912 else
4913   case $BASH in
4914   [\\/]* | ?:[\\/]*)
4915   ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
4916   ;;
4917   *)
4918   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4919 for as_dir in $PATH
4920 do
4921   IFS=$as_save_IFS
4922   test -z "$as_dir" && as_dir=.
4923     for ac_exec_ext in '' $ac_executable_extensions; do
4924   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4925     ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
4926     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4927     break 2
4928   fi
4929 done
4930   done
4931 IFS=$as_save_IFS
4932 
4933   ;;
4934 esac
4935 fi
4936 BASH=$ac_cv_path_BASH
4937 if test -n "$BASH"; then
4938   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
4939 $as_echo "$BASH" >&6; }
4940 else
4941   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4942 $as_echo "no" >&6; }
4943 fi
4944 
4945 
4946   test -n "$BASH" && break
4947 done
4948 
4949   else
4950     # The variable is set, but is it from the command line or the environment?
4951 
4952     # Try to remove the string !BASH! from our list.
4953     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BASH!/}
4954     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
4955       # If it failed, the variable was not from the command line. Ignore it,
4956       # but warn the user (except for BASH, which is always set by the calling BASH).
4957       if test "xBASH" != xBASH; then
4958         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BASH from the environment. Use command line variables instead." >&5
4959 $as_echo "$as_me: WARNING: Ignoring value of BASH from the environment. Use command line variables instead." >&2;}
4960       fi
4961       # Try to locate tool using the code snippet
4962       for ac_prog in bash
4963 do
4964   # Extract the first word of "$ac_prog", so it can be a program name with args.
4965 set dummy $ac_prog; ac_word=$2
4966 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4967 $as_echo_n "checking for $ac_word... " >&6; }
4968 if ${ac_cv_path_BASH+:} false; then :
4969   $as_echo_n "(cached) " >&6
4970 else
4971   case $BASH in
4972   [\\/]* | ?:[\\/]*)
4973   ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
4974   ;;
4975   *)
4976   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4977 for as_dir in $PATH
4978 do
4979   IFS=$as_save_IFS
4980   test -z "$as_dir" && as_dir=.
4981     for ac_exec_ext in '' $ac_executable_extensions; do
4982   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4983     ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
4984     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4985     break 2
4986   fi
4987 done
4988   done
4989 IFS=$as_save_IFS
4990 
4991   ;;
4992 esac
4993 fi
4994 BASH=$ac_cv_path_BASH
4995 if test -n "$BASH"; then
4996   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
4997 $as_echo "$BASH" >&6; }
4998 else
4999   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5000 $as_echo "no" >&6; }
5001 fi
5002 
5003 
5004   test -n "$BASH" && break
5005 done
5006 
5007     else
5008       # If it succeeded, then it was overridden by the user. We will use it
5009       # for the tool.
5010 
5011       # First remove it from the list of overridden variables, so we can test
5012       # for unknown variables in the end.
5013       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5014 
5015       # Check if we try to supply an empty value
5016       if test "x$BASH" = x; then
5017         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool BASH= (no value)" >&5
5018 $as_echo "$as_me: Setting user supplied tool BASH= (no value)" >&6;}
5019         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASH" >&5
5020 $as_echo_n "checking for BASH... " >&6; }
5021         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
5022 $as_echo "disabled" >&6; }
5023       else
5024         # Check if the provided tool contains a complete path.
5025         tool_specified="$BASH"
5026         tool_basename="${tool_specified##*/}"
5027         if test "x$tool_basename" = "x$tool_specified"; then
5028           # A command without a complete path is provided, search $PATH.
5029           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BASH=$tool_basename" >&5
5030 $as_echo "$as_me: Will search for user supplied tool BASH=$tool_basename" >&6;}
5031           # Extract the first word of "$tool_basename", so it can be a program name with args.
5032 set dummy $tool_basename; ac_word=$2
5033 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5034 $as_echo_n "checking for $ac_word... " >&6; }
5035 if ${ac_cv_path_BASH+:} false; then :
5036   $as_echo_n "(cached) " >&6
5037 else
5038   case $BASH in
5039   [\\/]* | ?:[\\/]*)
5040   ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
5041   ;;
5042   *)
5043   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5044 for as_dir in $PATH
5045 do
5046   IFS=$as_save_IFS
5047   test -z "$as_dir" && as_dir=.
5048     for ac_exec_ext in '' $ac_executable_extensions; do
5049   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5050     ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
5051     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5052     break 2
5053   fi
5054 done
5055   done
5056 IFS=$as_save_IFS
5057 
5058   ;;
5059 esac
5060 fi
5061 BASH=$ac_cv_path_BASH
5062 if test -n "$BASH"; then
5063   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
5064 $as_echo "$BASH" >&6; }
5065 else
5066   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5067 $as_echo "no" >&6; }
5068 fi
5069 
5070 
5071           if test "x$BASH" = x; then
5072             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5073           fi
5074         else
5075           # Otherwise we believe it is a complete path. Use it as it is.
5076           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BASH=$tool_specified" >&5
5077 $as_echo "$as_me: Will use user supplied tool BASH=$tool_specified" >&6;}
5078           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASH" >&5
5079 $as_echo_n "checking for BASH... " >&6; }
5080           if test ! -x "$tool_specified"; then
5081             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5082 $as_echo "not found" >&6; }
5083             as_fn_error $? "User supplied tool BASH=$tool_specified does not exist or is not executable" "$LINENO" 5
5084           fi
5085           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5086 $as_echo "$tool_specified" >&6; }
5087         fi
5088       fi
5089     fi
5090 
5091   fi
5092 
5093 
5094 
5095   if test "x$BASH" = x; then
5096     as_fn_error $? "Could not find required tool for BASH" "$LINENO" 5
5097   fi
5098 
5099 
5100 
5101 
5102 
5103   # Publish this variable in the help.
5104 
5105 
5106   if [ -z "${CAT+x}" ]; then
5107     # The variable is not set by user, try to locate tool using the code snippet
5108     for ac_prog in cat
5109 do
5110   # Extract the first word of "$ac_prog", so it can be a program name with args.
5111 set dummy $ac_prog; ac_word=$2
5112 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5113 $as_echo_n "checking for $ac_word... " >&6; }
5114 if ${ac_cv_path_CAT+:} false; then :
5115   $as_echo_n "(cached) " >&6
5116 else
5117   case $CAT in
5118   [\\/]* | ?:[\\/]*)
5119   ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
5120   ;;
5121   *)
5122   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5123 for as_dir in $PATH
5124 do
5125   IFS=$as_save_IFS
5126   test -z "$as_dir" && as_dir=.
5127     for ac_exec_ext in '' $ac_executable_extensions; do
5128   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5129     ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
5130     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5131     break 2
5132   fi
5133 done
5134   done
5135 IFS=$as_save_IFS
5136 
5137   ;;
5138 esac
5139 fi
5140 CAT=$ac_cv_path_CAT
5141 if test -n "$CAT"; then
5142   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
5143 $as_echo "$CAT" >&6; }
5144 else
5145   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5146 $as_echo "no" >&6; }
5147 fi
5148 
5149 
5150   test -n "$CAT" && break
5151 done
5152 
5153   else
5154     # The variable is set, but is it from the command line or the environment?
5155 
5156     # Try to remove the string !CAT! from our list.
5157     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CAT!/}
5158     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5159       # If it failed, the variable was not from the command line. Ignore it,
5160       # but warn the user (except for BASH, which is always set by the calling BASH).
5161       if test "xCAT" != xBASH; then
5162         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CAT from the environment. Use command line variables instead." >&5
5163 $as_echo "$as_me: WARNING: Ignoring value of CAT from the environment. Use command line variables instead." >&2;}
5164       fi
5165       # Try to locate tool using the code snippet
5166       for ac_prog in cat
5167 do
5168   # Extract the first word of "$ac_prog", so it can be a program name with args.
5169 set dummy $ac_prog; ac_word=$2
5170 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5171 $as_echo_n "checking for $ac_word... " >&6; }
5172 if ${ac_cv_path_CAT+:} false; then :
5173   $as_echo_n "(cached) " >&6
5174 else
5175   case $CAT in
5176   [\\/]* | ?:[\\/]*)
5177   ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
5178   ;;
5179   *)
5180   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5181 for as_dir in $PATH
5182 do
5183   IFS=$as_save_IFS
5184   test -z "$as_dir" && as_dir=.
5185     for ac_exec_ext in '' $ac_executable_extensions; do
5186   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5187     ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
5188     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5189     break 2
5190   fi
5191 done
5192   done
5193 IFS=$as_save_IFS
5194 
5195   ;;
5196 esac
5197 fi
5198 CAT=$ac_cv_path_CAT
5199 if test -n "$CAT"; then
5200   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
5201 $as_echo "$CAT" >&6; }
5202 else
5203   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5204 $as_echo "no" >&6; }
5205 fi
5206 
5207 
5208   test -n "$CAT" && break
5209 done
5210 
5211     else
5212       # If it succeeded, then it was overridden by the user. We will use it
5213       # for the tool.
5214 
5215       # First remove it from the list of overridden variables, so we can test
5216       # for unknown variables in the end.
5217       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5218 
5219       # Check if we try to supply an empty value
5220       if test "x$CAT" = x; then
5221         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CAT= (no value)" >&5
5222 $as_echo "$as_me: Setting user supplied tool CAT= (no value)" >&6;}
5223         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CAT" >&5
5224 $as_echo_n "checking for CAT... " >&6; }
5225         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
5226 $as_echo "disabled" >&6; }
5227       else
5228         # Check if the provided tool contains a complete path.
5229         tool_specified="$CAT"
5230         tool_basename="${tool_specified##*/}"
5231         if test "x$tool_basename" = "x$tool_specified"; then
5232           # A command without a complete path is provided, search $PATH.
5233           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CAT=$tool_basename" >&5
5234 $as_echo "$as_me: Will search for user supplied tool CAT=$tool_basename" >&6;}
5235           # Extract the first word of "$tool_basename", so it can be a program name with args.
5236 set dummy $tool_basename; ac_word=$2
5237 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5238 $as_echo_n "checking for $ac_word... " >&6; }
5239 if ${ac_cv_path_CAT+:} false; then :
5240   $as_echo_n "(cached) " >&6
5241 else
5242   case $CAT in
5243   [\\/]* | ?:[\\/]*)
5244   ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
5245   ;;
5246   *)
5247   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5248 for as_dir in $PATH
5249 do
5250   IFS=$as_save_IFS
5251   test -z "$as_dir" && as_dir=.
5252     for ac_exec_ext in '' $ac_executable_extensions; do
5253   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5254     ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
5255     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5256     break 2
5257   fi
5258 done
5259   done
5260 IFS=$as_save_IFS
5261 
5262   ;;
5263 esac
5264 fi
5265 CAT=$ac_cv_path_CAT
5266 if test -n "$CAT"; then
5267   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
5268 $as_echo "$CAT" >&6; }
5269 else
5270   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5271 $as_echo "no" >&6; }
5272 fi
5273 
5274 
5275           if test "x$CAT" = x; then
5276             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5277           fi
5278         else
5279           # Otherwise we believe it is a complete path. Use it as it is.
5280           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CAT=$tool_specified" >&5
5281 $as_echo "$as_me: Will use user supplied tool CAT=$tool_specified" >&6;}
5282           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CAT" >&5
5283 $as_echo_n "checking for CAT... " >&6; }
5284           if test ! -x "$tool_specified"; then
5285             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5286 $as_echo "not found" >&6; }
5287             as_fn_error $? "User supplied tool CAT=$tool_specified does not exist or is not executable" "$LINENO" 5
5288           fi
5289           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5290 $as_echo "$tool_specified" >&6; }
5291         fi
5292       fi
5293     fi
5294 
5295   fi
5296 
5297 
5298 
5299   if test "x$CAT" = x; then
5300     as_fn_error $? "Could not find required tool for CAT" "$LINENO" 5
5301   fi
5302 
5303 
5304 
5305 
5306 
5307   # Publish this variable in the help.
5308 
5309 
5310   if [ -z "${CHMOD+x}" ]; then
5311     # The variable is not set by user, try to locate tool using the code snippet
5312     for ac_prog in chmod
5313 do
5314   # Extract the first word of "$ac_prog", so it can be a program name with args.
5315 set dummy $ac_prog; ac_word=$2
5316 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5317 $as_echo_n "checking for $ac_word... " >&6; }
5318 if ${ac_cv_path_CHMOD+:} false; then :
5319   $as_echo_n "(cached) " >&6
5320 else
5321   case $CHMOD in
5322   [\\/]* | ?:[\\/]*)
5323   ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
5324   ;;
5325   *)
5326   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5327 for as_dir in $PATH
5328 do
5329   IFS=$as_save_IFS
5330   test -z "$as_dir" && as_dir=.
5331     for ac_exec_ext in '' $ac_executable_extensions; do
5332   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5333     ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
5334     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5335     break 2
5336   fi
5337 done
5338   done
5339 IFS=$as_save_IFS
5340 
5341   ;;
5342 esac
5343 fi
5344 CHMOD=$ac_cv_path_CHMOD
5345 if test -n "$CHMOD"; then
5346   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
5347 $as_echo "$CHMOD" >&6; }
5348 else
5349   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5350 $as_echo "no" >&6; }
5351 fi
5352 
5353 
5354   test -n "$CHMOD" && break
5355 done
5356 
5357   else
5358     # The variable is set, but is it from the command line or the environment?
5359 
5360     # Try to remove the string !CHMOD! from our list.
5361     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CHMOD!/}
5362     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5363       # If it failed, the variable was not from the command line. Ignore it,
5364       # but warn the user (except for BASH, which is always set by the calling BASH).
5365       if test "xCHMOD" != xBASH; then
5366         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CHMOD from the environment. Use command line variables instead." >&5
5367 $as_echo "$as_me: WARNING: Ignoring value of CHMOD from the environment. Use command line variables instead." >&2;}
5368       fi
5369       # Try to locate tool using the code snippet
5370       for ac_prog in chmod
5371 do
5372   # Extract the first word of "$ac_prog", so it can be a program name with args.
5373 set dummy $ac_prog; ac_word=$2
5374 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5375 $as_echo_n "checking for $ac_word... " >&6; }
5376 if ${ac_cv_path_CHMOD+:} false; then :
5377   $as_echo_n "(cached) " >&6
5378 else
5379   case $CHMOD in
5380   [\\/]* | ?:[\\/]*)
5381   ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
5382   ;;
5383   *)
5384   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5385 for as_dir in $PATH
5386 do
5387   IFS=$as_save_IFS
5388   test -z "$as_dir" && as_dir=.
5389     for ac_exec_ext in '' $ac_executable_extensions; do
5390   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5391     ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
5392     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5393     break 2
5394   fi
5395 done
5396   done
5397 IFS=$as_save_IFS
5398 
5399   ;;
5400 esac
5401 fi
5402 CHMOD=$ac_cv_path_CHMOD
5403 if test -n "$CHMOD"; then
5404   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
5405 $as_echo "$CHMOD" >&6; }
5406 else
5407   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5408 $as_echo "no" >&6; }
5409 fi
5410 
5411 
5412   test -n "$CHMOD" && break
5413 done
5414 
5415     else
5416       # If it succeeded, then it was overridden by the user. We will use it
5417       # for the tool.
5418 
5419       # First remove it from the list of overridden variables, so we can test
5420       # for unknown variables in the end.
5421       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5422 
5423       # Check if we try to supply an empty value
5424       if test "x$CHMOD" = x; then
5425         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CHMOD= (no value)" >&5
5426 $as_echo "$as_me: Setting user supplied tool CHMOD= (no value)" >&6;}
5427         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CHMOD" >&5
5428 $as_echo_n "checking for CHMOD... " >&6; }
5429         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
5430 $as_echo "disabled" >&6; }
5431       else
5432         # Check if the provided tool contains a complete path.
5433         tool_specified="$CHMOD"
5434         tool_basename="${tool_specified##*/}"
5435         if test "x$tool_basename" = "x$tool_specified"; then
5436           # A command without a complete path is provided, search $PATH.
5437           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CHMOD=$tool_basename" >&5
5438 $as_echo "$as_me: Will search for user supplied tool CHMOD=$tool_basename" >&6;}
5439           # Extract the first word of "$tool_basename", so it can be a program name with args.
5440 set dummy $tool_basename; ac_word=$2
5441 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5442 $as_echo_n "checking for $ac_word... " >&6; }
5443 if ${ac_cv_path_CHMOD+:} false; then :
5444   $as_echo_n "(cached) " >&6
5445 else
5446   case $CHMOD in
5447   [\\/]* | ?:[\\/]*)
5448   ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
5449   ;;
5450   *)
5451   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5452 for as_dir in $PATH
5453 do
5454   IFS=$as_save_IFS
5455   test -z "$as_dir" && as_dir=.
5456     for ac_exec_ext in '' $ac_executable_extensions; do
5457   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5458     ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
5459     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5460     break 2
5461   fi
5462 done
5463   done
5464 IFS=$as_save_IFS
5465 
5466   ;;
5467 esac
5468 fi
5469 CHMOD=$ac_cv_path_CHMOD
5470 if test -n "$CHMOD"; then
5471   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
5472 $as_echo "$CHMOD" >&6; }
5473 else
5474   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5475 $as_echo "no" >&6; }
5476 fi
5477 
5478 
5479           if test "x$CHMOD" = x; then
5480             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5481           fi
5482         else
5483           # Otherwise we believe it is a complete path. Use it as it is.
5484           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CHMOD=$tool_specified" >&5
5485 $as_echo "$as_me: Will use user supplied tool CHMOD=$tool_specified" >&6;}
5486           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CHMOD" >&5
5487 $as_echo_n "checking for CHMOD... " >&6; }
5488           if test ! -x "$tool_specified"; then
5489             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5490 $as_echo "not found" >&6; }
5491             as_fn_error $? "User supplied tool CHMOD=$tool_specified does not exist or is not executable" "$LINENO" 5
5492           fi
5493           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5494 $as_echo "$tool_specified" >&6; }
5495         fi
5496       fi
5497     fi
5498 
5499   fi
5500 
5501 
5502 
5503   if test "x$CHMOD" = x; then
5504     as_fn_error $? "Could not find required tool for CHMOD" "$LINENO" 5
5505   fi
5506 
5507 
5508 
5509 
5510 
5511   # Publish this variable in the help.
5512 
5513 
5514   if [ -z "${CMP+x}" ]; then
5515     # The variable is not set by user, try to locate tool using the code snippet
5516     for ac_prog in cmp
5517 do
5518   # Extract the first word of "$ac_prog", so it can be a program name with args.
5519 set dummy $ac_prog; ac_word=$2
5520 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5521 $as_echo_n "checking for $ac_word... " >&6; }
5522 if ${ac_cv_path_CMP+:} false; then :
5523   $as_echo_n "(cached) " >&6
5524 else
5525   case $CMP in
5526   [\\/]* | ?:[\\/]*)
5527   ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
5528   ;;
5529   *)
5530   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5531 for as_dir in $PATH
5532 do
5533   IFS=$as_save_IFS
5534   test -z "$as_dir" && as_dir=.
5535     for ac_exec_ext in '' $ac_executable_extensions; do
5536   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5537     ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
5538     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5539     break 2
5540   fi
5541 done
5542   done
5543 IFS=$as_save_IFS
5544 
5545   ;;
5546 esac
5547 fi
5548 CMP=$ac_cv_path_CMP
5549 if test -n "$CMP"; then
5550   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
5551 $as_echo "$CMP" >&6; }
5552 else
5553   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5554 $as_echo "no" >&6; }
5555 fi
5556 
5557 
5558   test -n "$CMP" && break
5559 done
5560 
5561   else
5562     # The variable is set, but is it from the command line or the environment?
5563 
5564     # Try to remove the string !CMP! from our list.
5565     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CMP!/}
5566     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5567       # If it failed, the variable was not from the command line. Ignore it,
5568       # but warn the user (except for BASH, which is always set by the calling BASH).
5569       if test "xCMP" != xBASH; then
5570         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CMP from the environment. Use command line variables instead." >&5
5571 $as_echo "$as_me: WARNING: Ignoring value of CMP from the environment. Use command line variables instead." >&2;}
5572       fi
5573       # Try to locate tool using the code snippet
5574       for ac_prog in cmp
5575 do
5576   # Extract the first word of "$ac_prog", so it can be a program name with args.
5577 set dummy $ac_prog; ac_word=$2
5578 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5579 $as_echo_n "checking for $ac_word... " >&6; }
5580 if ${ac_cv_path_CMP+:} false; then :
5581   $as_echo_n "(cached) " >&6
5582 else
5583   case $CMP in
5584   [\\/]* | ?:[\\/]*)
5585   ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
5586   ;;
5587   *)
5588   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5589 for as_dir in $PATH
5590 do
5591   IFS=$as_save_IFS
5592   test -z "$as_dir" && as_dir=.
5593     for ac_exec_ext in '' $ac_executable_extensions; do
5594   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5595     ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
5596     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5597     break 2
5598   fi
5599 done
5600   done
5601 IFS=$as_save_IFS
5602 
5603   ;;
5604 esac
5605 fi
5606 CMP=$ac_cv_path_CMP
5607 if test -n "$CMP"; then
5608   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
5609 $as_echo "$CMP" >&6; }
5610 else
5611   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5612 $as_echo "no" >&6; }
5613 fi
5614 
5615 
5616   test -n "$CMP" && break
5617 done
5618 
5619     else
5620       # If it succeeded, then it was overridden by the user. We will use it
5621       # for the tool.
5622 
5623       # First remove it from the list of overridden variables, so we can test
5624       # for unknown variables in the end.
5625       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5626 
5627       # Check if we try to supply an empty value
5628       if test "x$CMP" = x; then
5629         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CMP= (no value)" >&5
5630 $as_echo "$as_me: Setting user supplied tool CMP= (no value)" >&6;}
5631         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CMP" >&5
5632 $as_echo_n "checking for CMP... " >&6; }
5633         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
5634 $as_echo "disabled" >&6; }
5635       else
5636         # Check if the provided tool contains a complete path.
5637         tool_specified="$CMP"
5638         tool_basename="${tool_specified##*/}"
5639         if test "x$tool_basename" = "x$tool_specified"; then
5640           # A command without a complete path is provided, search $PATH.
5641           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CMP=$tool_basename" >&5
5642 $as_echo "$as_me: Will search for user supplied tool CMP=$tool_basename" >&6;}
5643           # Extract the first word of "$tool_basename", so it can be a program name with args.
5644 set dummy $tool_basename; ac_word=$2
5645 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5646 $as_echo_n "checking for $ac_word... " >&6; }
5647 if ${ac_cv_path_CMP+:} false; then :
5648   $as_echo_n "(cached) " >&6
5649 else
5650   case $CMP in
5651   [\\/]* | ?:[\\/]*)
5652   ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
5653   ;;
5654   *)
5655   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5656 for as_dir in $PATH
5657 do
5658   IFS=$as_save_IFS
5659   test -z "$as_dir" && as_dir=.
5660     for ac_exec_ext in '' $ac_executable_extensions; do
5661   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5662     ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
5663     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5664     break 2
5665   fi
5666 done
5667   done
5668 IFS=$as_save_IFS
5669 
5670   ;;
5671 esac
5672 fi
5673 CMP=$ac_cv_path_CMP
5674 if test -n "$CMP"; then
5675   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
5676 $as_echo "$CMP" >&6; }
5677 else
5678   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5679 $as_echo "no" >&6; }
5680 fi
5681 
5682 
5683           if test "x$CMP" = x; then
5684             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5685           fi
5686         else
5687           # Otherwise we believe it is a complete path. Use it as it is.
5688           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CMP=$tool_specified" >&5
5689 $as_echo "$as_me: Will use user supplied tool CMP=$tool_specified" >&6;}
5690           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CMP" >&5
5691 $as_echo_n "checking for CMP... " >&6; }
5692           if test ! -x "$tool_specified"; then
5693             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5694 $as_echo "not found" >&6; }
5695             as_fn_error $? "User supplied tool CMP=$tool_specified does not exist or is not executable" "$LINENO" 5
5696           fi
5697           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5698 $as_echo "$tool_specified" >&6; }
5699         fi
5700       fi
5701     fi
5702 
5703   fi
5704 
5705 
5706 
5707   if test "x$CMP" = x; then
5708     as_fn_error $? "Could not find required tool for CMP" "$LINENO" 5
5709   fi
5710 
5711 
5712 
5713 
5714 
5715   # Publish this variable in the help.
5716 
5717 
5718   if [ -z "${COMM+x}" ]; then
5719     # The variable is not set by user, try to locate tool using the code snippet
5720     for ac_prog in comm
5721 do
5722   # Extract the first word of "$ac_prog", so it can be a program name with args.
5723 set dummy $ac_prog; ac_word=$2
5724 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5725 $as_echo_n "checking for $ac_word... " >&6; }
5726 if ${ac_cv_path_COMM+:} false; then :
5727   $as_echo_n "(cached) " >&6
5728 else
5729   case $COMM in
5730   [\\/]* | ?:[\\/]*)
5731   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
5732   ;;
5733   *)
5734   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5735 for as_dir in $PATH
5736 do
5737   IFS=$as_save_IFS
5738   test -z "$as_dir" && as_dir=.
5739     for ac_exec_ext in '' $ac_executable_extensions; do
5740   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5741     ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
5742     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5743     break 2
5744   fi
5745 done
5746   done
5747 IFS=$as_save_IFS
5748 
5749   ;;
5750 esac
5751 fi
5752 COMM=$ac_cv_path_COMM
5753 if test -n "$COMM"; then
5754   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
5755 $as_echo "$COMM" >&6; }
5756 else
5757   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5758 $as_echo "no" >&6; }
5759 fi
5760 
5761 
5762   test -n "$COMM" && break
5763 done
5764 
5765   else
5766     # The variable is set, but is it from the command line or the environment?
5767 
5768     # Try to remove the string !COMM! from our list.
5769     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!COMM!/}
5770     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5771       # If it failed, the variable was not from the command line. Ignore it,
5772       # but warn the user (except for BASH, which is always set by the calling BASH).
5773       if test "xCOMM" != xBASH; then
5774         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&5
5775 $as_echo "$as_me: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&2;}
5776       fi
5777       # Try to locate tool using the code snippet
5778       for ac_prog in comm
5779 do
5780   # Extract the first word of "$ac_prog", so it can be a program name with args.
5781 set dummy $ac_prog; ac_word=$2
5782 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5783 $as_echo_n "checking for $ac_word... " >&6; }
5784 if ${ac_cv_path_COMM+:} false; then :
5785   $as_echo_n "(cached) " >&6
5786 else
5787   case $COMM in
5788   [\\/]* | ?:[\\/]*)
5789   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
5790   ;;
5791   *)
5792   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5793 for as_dir in $PATH
5794 do
5795   IFS=$as_save_IFS
5796   test -z "$as_dir" && as_dir=.
5797     for ac_exec_ext in '' $ac_executable_extensions; do
5798   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5799     ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
5800     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5801     break 2
5802   fi
5803 done
5804   done
5805 IFS=$as_save_IFS
5806 
5807   ;;
5808 esac
5809 fi
5810 COMM=$ac_cv_path_COMM
5811 if test -n "$COMM"; then
5812   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
5813 $as_echo "$COMM" >&6; }
5814 else
5815   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5816 $as_echo "no" >&6; }
5817 fi
5818 
5819 
5820   test -n "$COMM" && break
5821 done
5822 
5823     else
5824       # If it succeeded, then it was overridden by the user. We will use it
5825       # for the tool.
5826 
5827       # First remove it from the list of overridden variables, so we can test
5828       # for unknown variables in the end.
5829       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5830 
5831       # Check if we try to supply an empty value
5832       if test "x$COMM" = x; then
5833         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool COMM= (no value)" >&5
5834 $as_echo "$as_me: Setting user supplied tool COMM= (no value)" >&6;}
5835         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for COMM" >&5
5836 $as_echo_n "checking for COMM... " >&6; }
5837         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
5838 $as_echo "disabled" >&6; }
5839       else
5840         # Check if the provided tool contains a complete path.
5841         tool_specified="$COMM"
5842         tool_basename="${tool_specified##*/}"
5843         if test "x$tool_basename" = "x$tool_specified"; then
5844           # A command without a complete path is provided, search $PATH.
5845           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool COMM=$tool_basename" >&5
5846 $as_echo "$as_me: Will search for user supplied tool COMM=$tool_basename" >&6;}
5847           # Extract the first word of "$tool_basename", so it can be a program name with args.
5848 set dummy $tool_basename; ac_word=$2
5849 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5850 $as_echo_n "checking for $ac_word... " >&6; }
5851 if ${ac_cv_path_COMM+:} false; then :
5852   $as_echo_n "(cached) " >&6
5853 else
5854   case $COMM in
5855   [\\/]* | ?:[\\/]*)
5856   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
5857   ;;
5858   *)
5859   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5860 for as_dir in $PATH
5861 do
5862   IFS=$as_save_IFS
5863   test -z "$as_dir" && as_dir=.
5864     for ac_exec_ext in '' $ac_executable_extensions; do
5865   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5866     ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
5867     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5868     break 2
5869   fi
5870 done
5871   done
5872 IFS=$as_save_IFS
5873 
5874   ;;
5875 esac
5876 fi
5877 COMM=$ac_cv_path_COMM
5878 if test -n "$COMM"; then
5879   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
5880 $as_echo "$COMM" >&6; }
5881 else
5882   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5883 $as_echo "no" >&6; }
5884 fi
5885 
5886 
5887           if test "x$COMM" = x; then
5888             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5889           fi
5890         else
5891           # Otherwise we believe it is a complete path. Use it as it is.
5892           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool COMM=$tool_specified" >&5
5893 $as_echo "$as_me: Will use user supplied tool COMM=$tool_specified" >&6;}
5894           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for COMM" >&5
5895 $as_echo_n "checking for COMM... " >&6; }
5896           if test ! -x "$tool_specified"; then
5897             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5898 $as_echo "not found" >&6; }
5899             as_fn_error $? "User supplied tool COMM=$tool_specified does not exist or is not executable" "$LINENO" 5
5900           fi
5901           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5902 $as_echo "$tool_specified" >&6; }
5903         fi
5904       fi
5905     fi
5906 
5907   fi
5908 
5909 
5910 
5911   if test "x$COMM" = x; then
5912     as_fn_error $? "Could not find required tool for COMM" "$LINENO" 5
5913   fi
5914 
5915 
5916 
5917 
5918 
5919   # Publish this variable in the help.
5920 
5921 
5922   if [ -z "${CP+x}" ]; then
5923     # The variable is not set by user, try to locate tool using the code snippet
5924     for ac_prog in cp
5925 do
5926   # Extract the first word of "$ac_prog", so it can be a program name with args.
5927 set dummy $ac_prog; ac_word=$2
5928 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5929 $as_echo_n "checking for $ac_word... " >&6; }
5930 if ${ac_cv_path_CP+:} false; then :
5931   $as_echo_n "(cached) " >&6
5932 else
5933   case $CP in
5934   [\\/]* | ?:[\\/]*)
5935   ac_cv_path_CP="$CP" # Let the user override the test with a path.
5936   ;;
5937   *)
5938   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5939 for as_dir in $PATH
5940 do
5941   IFS=$as_save_IFS
5942   test -z "$as_dir" && as_dir=.
5943     for ac_exec_ext in '' $ac_executable_extensions; do
5944   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5945     ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
5946     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5947     break 2
5948   fi
5949 done
5950   done
5951 IFS=$as_save_IFS
5952 
5953   ;;
5954 esac
5955 fi
5956 CP=$ac_cv_path_CP
5957 if test -n "$CP"; then
5958   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
5959 $as_echo "$CP" >&6; }
5960 else
5961   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5962 $as_echo "no" >&6; }
5963 fi
5964 
5965 
5966   test -n "$CP" && break
5967 done
5968 
5969   else
5970     # The variable is set, but is it from the command line or the environment?
5971 
5972     # Try to remove the string !CP! from our list.
5973     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CP!/}
5974     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5975       # If it failed, the variable was not from the command line. Ignore it,
5976       # but warn the user (except for BASH, which is always set by the calling BASH).
5977       if test "xCP" != xBASH; then
5978         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CP from the environment. Use command line variables instead." >&5
5979 $as_echo "$as_me: WARNING: Ignoring value of CP from the environment. Use command line variables instead." >&2;}
5980       fi
5981       # Try to locate tool using the code snippet
5982       for ac_prog in cp
5983 do
5984   # Extract the first word of "$ac_prog", so it can be a program name with args.
5985 set dummy $ac_prog; ac_word=$2
5986 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5987 $as_echo_n "checking for $ac_word... " >&6; }
5988 if ${ac_cv_path_CP+:} false; then :
5989   $as_echo_n "(cached) " >&6
5990 else
5991   case $CP in
5992   [\\/]* | ?:[\\/]*)
5993   ac_cv_path_CP="$CP" # Let the user override the test with a path.
5994   ;;
5995   *)
5996   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5997 for as_dir in $PATH
5998 do
5999   IFS=$as_save_IFS
6000   test -z "$as_dir" && as_dir=.
6001     for ac_exec_ext in '' $ac_executable_extensions; do
6002   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6003     ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
6004     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6005     break 2
6006   fi
6007 done
6008   done
6009 IFS=$as_save_IFS
6010 
6011   ;;
6012 esac
6013 fi
6014 CP=$ac_cv_path_CP
6015 if test -n "$CP"; then
6016   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
6017 $as_echo "$CP" >&6; }
6018 else
6019   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6020 $as_echo "no" >&6; }
6021 fi
6022 
6023 
6024   test -n "$CP" && break
6025 done
6026 
6027     else
6028       # If it succeeded, then it was overridden by the user. We will use it
6029       # for the tool.
6030 
6031       # First remove it from the list of overridden variables, so we can test
6032       # for unknown variables in the end.
6033       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6034 
6035       # Check if we try to supply an empty value
6036       if test "x$CP" = x; then
6037         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CP= (no value)" >&5
6038 $as_echo "$as_me: Setting user supplied tool CP= (no value)" >&6;}
6039         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CP" >&5
6040 $as_echo_n "checking for CP... " >&6; }
6041         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
6042 $as_echo "disabled" >&6; }
6043       else
6044         # Check if the provided tool contains a complete path.
6045         tool_specified="$CP"
6046         tool_basename="${tool_specified##*/}"
6047         if test "x$tool_basename" = "x$tool_specified"; then
6048           # A command without a complete path is provided, search $PATH.
6049           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CP=$tool_basename" >&5
6050 $as_echo "$as_me: Will search for user supplied tool CP=$tool_basename" >&6;}
6051           # Extract the first word of "$tool_basename", so it can be a program name with args.
6052 set dummy $tool_basename; ac_word=$2
6053 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6054 $as_echo_n "checking for $ac_word... " >&6; }
6055 if ${ac_cv_path_CP+:} false; then :
6056   $as_echo_n "(cached) " >&6
6057 else
6058   case $CP in
6059   [\\/]* | ?:[\\/]*)
6060   ac_cv_path_CP="$CP" # Let the user override the test with a path.
6061   ;;
6062   *)
6063   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6064 for as_dir in $PATH
6065 do
6066   IFS=$as_save_IFS
6067   test -z "$as_dir" && as_dir=.
6068     for ac_exec_ext in '' $ac_executable_extensions; do
6069   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6070     ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
6071     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6072     break 2
6073   fi
6074 done
6075   done
6076 IFS=$as_save_IFS
6077 
6078   ;;
6079 esac
6080 fi
6081 CP=$ac_cv_path_CP
6082 if test -n "$CP"; then
6083   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
6084 $as_echo "$CP" >&6; }
6085 else
6086   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6087 $as_echo "no" >&6; }
6088 fi
6089 
6090 
6091           if test "x$CP" = x; then
6092             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6093           fi
6094         else
6095           # Otherwise we believe it is a complete path. Use it as it is.
6096           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CP=$tool_specified" >&5
6097 $as_echo "$as_me: Will use user supplied tool CP=$tool_specified" >&6;}
6098           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CP" >&5
6099 $as_echo_n "checking for CP... " >&6; }
6100           if test ! -x "$tool_specified"; then
6101             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6102 $as_echo "not found" >&6; }
6103             as_fn_error $? "User supplied tool CP=$tool_specified does not exist or is not executable" "$LINENO" 5
6104           fi
6105           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6106 $as_echo "$tool_specified" >&6; }
6107         fi
6108       fi
6109     fi
6110 
6111   fi
6112 
6113 
6114 
6115   if test "x$CP" = x; then
6116     as_fn_error $? "Could not find required tool for CP" "$LINENO" 5
6117   fi
6118 
6119 
6120 
6121 
6122 
6123   # Publish this variable in the help.
6124 
6125 
6126   if [ -z "${CUT+x}" ]; then
6127     # The variable is not set by user, try to locate tool using the code snippet
6128     for ac_prog in cut
6129 do
6130   # Extract the first word of "$ac_prog", so it can be a program name with args.
6131 set dummy $ac_prog; ac_word=$2
6132 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6133 $as_echo_n "checking for $ac_word... " >&6; }
6134 if ${ac_cv_path_CUT+:} false; then :
6135   $as_echo_n "(cached) " >&6
6136 else
6137   case $CUT in
6138   [\\/]* | ?:[\\/]*)
6139   ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
6140   ;;
6141   *)
6142   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6143 for as_dir in $PATH
6144 do
6145   IFS=$as_save_IFS
6146   test -z "$as_dir" && as_dir=.
6147     for ac_exec_ext in '' $ac_executable_extensions; do
6148   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6149     ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
6150     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6151     break 2
6152   fi
6153 done
6154   done
6155 IFS=$as_save_IFS
6156 
6157   ;;
6158 esac
6159 fi
6160 CUT=$ac_cv_path_CUT
6161 if test -n "$CUT"; then
6162   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
6163 $as_echo "$CUT" >&6; }
6164 else
6165   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6166 $as_echo "no" >&6; }
6167 fi
6168 
6169 
6170   test -n "$CUT" && break
6171 done
6172 
6173   else
6174     # The variable is set, but is it from the command line or the environment?
6175 
6176     # Try to remove the string !CUT! from our list.
6177     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CUT!/}
6178     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6179       # If it failed, the variable was not from the command line. Ignore it,
6180       # but warn the user (except for BASH, which is always set by the calling BASH).
6181       if test "xCUT" != xBASH; then
6182         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CUT from the environment. Use command line variables instead." >&5
6183 $as_echo "$as_me: WARNING: Ignoring value of CUT from the environment. Use command line variables instead." >&2;}
6184       fi
6185       # Try to locate tool using the code snippet
6186       for ac_prog in cut
6187 do
6188   # Extract the first word of "$ac_prog", so it can be a program name with args.
6189 set dummy $ac_prog; ac_word=$2
6190 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6191 $as_echo_n "checking for $ac_word... " >&6; }
6192 if ${ac_cv_path_CUT+:} false; then :
6193   $as_echo_n "(cached) " >&6
6194 else
6195   case $CUT in
6196   [\\/]* | ?:[\\/]*)
6197   ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
6198   ;;
6199   *)
6200   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6201 for as_dir in $PATH
6202 do
6203   IFS=$as_save_IFS
6204   test -z "$as_dir" && as_dir=.
6205     for ac_exec_ext in '' $ac_executable_extensions; do
6206   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6207     ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
6208     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6209     break 2
6210   fi
6211 done
6212   done
6213 IFS=$as_save_IFS
6214 
6215   ;;
6216 esac
6217 fi
6218 CUT=$ac_cv_path_CUT
6219 if test -n "$CUT"; then
6220   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
6221 $as_echo "$CUT" >&6; }
6222 else
6223   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6224 $as_echo "no" >&6; }
6225 fi
6226 
6227 
6228   test -n "$CUT" && break
6229 done
6230 
6231     else
6232       # If it succeeded, then it was overridden by the user. We will use it
6233       # for the tool.
6234 
6235       # First remove it from the list of overridden variables, so we can test
6236       # for unknown variables in the end.
6237       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6238 
6239       # Check if we try to supply an empty value
6240       if test "x$CUT" = x; then
6241         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CUT= (no value)" >&5
6242 $as_echo "$as_me: Setting user supplied tool CUT= (no value)" >&6;}
6243         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CUT" >&5
6244 $as_echo_n "checking for CUT... " >&6; }
6245         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
6246 $as_echo "disabled" >&6; }
6247       else
6248         # Check if the provided tool contains a complete path.
6249         tool_specified="$CUT"
6250         tool_basename="${tool_specified##*/}"
6251         if test "x$tool_basename" = "x$tool_specified"; then
6252           # A command without a complete path is provided, search $PATH.
6253           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CUT=$tool_basename" >&5
6254 $as_echo "$as_me: Will search for user supplied tool CUT=$tool_basename" >&6;}
6255           # Extract the first word of "$tool_basename", so it can be a program name with args.
6256 set dummy $tool_basename; ac_word=$2
6257 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6258 $as_echo_n "checking for $ac_word... " >&6; }
6259 if ${ac_cv_path_CUT+:} false; then :
6260   $as_echo_n "(cached) " >&6
6261 else
6262   case $CUT in
6263   [\\/]* | ?:[\\/]*)
6264   ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
6265   ;;
6266   *)
6267   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6268 for as_dir in $PATH
6269 do
6270   IFS=$as_save_IFS
6271   test -z "$as_dir" && as_dir=.
6272     for ac_exec_ext in '' $ac_executable_extensions; do
6273   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6274     ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
6275     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6276     break 2
6277   fi
6278 done
6279   done
6280 IFS=$as_save_IFS
6281 
6282   ;;
6283 esac
6284 fi
6285 CUT=$ac_cv_path_CUT
6286 if test -n "$CUT"; then
6287   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
6288 $as_echo "$CUT" >&6; }
6289 else
6290   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6291 $as_echo "no" >&6; }
6292 fi
6293 
6294 
6295           if test "x$CUT" = x; then
6296             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6297           fi
6298         else
6299           # Otherwise we believe it is a complete path. Use it as it is.
6300           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CUT=$tool_specified" >&5
6301 $as_echo "$as_me: Will use user supplied tool CUT=$tool_specified" >&6;}
6302           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CUT" >&5
6303 $as_echo_n "checking for CUT... " >&6; }
6304           if test ! -x "$tool_specified"; then
6305             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6306 $as_echo "not found" >&6; }
6307             as_fn_error $? "User supplied tool CUT=$tool_specified does not exist or is not executable" "$LINENO" 5
6308           fi
6309           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6310 $as_echo "$tool_specified" >&6; }
6311         fi
6312       fi
6313     fi
6314 
6315   fi
6316 
6317 
6318 
6319   if test "x$CUT" = x; then
6320     as_fn_error $? "Could not find required tool for CUT" "$LINENO" 5
6321   fi
6322 
6323 
6324 
6325 
6326 
6327   # Publish this variable in the help.
6328 
6329 
6330   if [ -z "${DATE+x}" ]; then
6331     # The variable is not set by user, try to locate tool using the code snippet
6332     for ac_prog in date
6333 do
6334   # Extract the first word of "$ac_prog", so it can be a program name with args.
6335 set dummy $ac_prog; ac_word=$2
6336 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6337 $as_echo_n "checking for $ac_word... " >&6; }
6338 if ${ac_cv_path_DATE+:} false; then :
6339   $as_echo_n "(cached) " >&6
6340 else
6341   case $DATE in
6342   [\\/]* | ?:[\\/]*)
6343   ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
6344   ;;
6345   *)
6346   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6347 for as_dir in $PATH
6348 do
6349   IFS=$as_save_IFS
6350   test -z "$as_dir" && as_dir=.
6351     for ac_exec_ext in '' $ac_executable_extensions; do
6352   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6353     ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
6354     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6355     break 2
6356   fi
6357 done
6358   done
6359 IFS=$as_save_IFS
6360 
6361   ;;
6362 esac
6363 fi
6364 DATE=$ac_cv_path_DATE
6365 if test -n "$DATE"; then
6366   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
6367 $as_echo "$DATE" >&6; }
6368 else
6369   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6370 $as_echo "no" >&6; }
6371 fi
6372 
6373 
6374   test -n "$DATE" && break
6375 done
6376 
6377   else
6378     # The variable is set, but is it from the command line or the environment?
6379 
6380     # Try to remove the string !DATE! from our list.
6381     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DATE!/}
6382     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6383       # If it failed, the variable was not from the command line. Ignore it,
6384       # but warn the user (except for BASH, which is always set by the calling BASH).
6385       if test "xDATE" != xBASH; then
6386         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DATE from the environment. Use command line variables instead." >&5
6387 $as_echo "$as_me: WARNING: Ignoring value of DATE from the environment. Use command line variables instead." >&2;}
6388       fi
6389       # Try to locate tool using the code snippet
6390       for ac_prog in date
6391 do
6392   # Extract the first word of "$ac_prog", so it can be a program name with args.
6393 set dummy $ac_prog; ac_word=$2
6394 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6395 $as_echo_n "checking for $ac_word... " >&6; }
6396 if ${ac_cv_path_DATE+:} false; then :
6397   $as_echo_n "(cached) " >&6
6398 else
6399   case $DATE in
6400   [\\/]* | ?:[\\/]*)
6401   ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
6402   ;;
6403   *)
6404   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6405 for as_dir in $PATH
6406 do
6407   IFS=$as_save_IFS
6408   test -z "$as_dir" && as_dir=.
6409     for ac_exec_ext in '' $ac_executable_extensions; do
6410   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6411     ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
6412     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6413     break 2
6414   fi
6415 done
6416   done
6417 IFS=$as_save_IFS
6418 
6419   ;;
6420 esac
6421 fi
6422 DATE=$ac_cv_path_DATE
6423 if test -n "$DATE"; then
6424   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
6425 $as_echo "$DATE" >&6; }
6426 else
6427   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6428 $as_echo "no" >&6; }
6429 fi
6430 
6431 
6432   test -n "$DATE" && break
6433 done
6434 
6435     else
6436       # If it succeeded, then it was overridden by the user. We will use it
6437       # for the tool.
6438 
6439       # First remove it from the list of overridden variables, so we can test
6440       # for unknown variables in the end.
6441       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6442 
6443       # Check if we try to supply an empty value
6444       if test "x$DATE" = x; then
6445         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool DATE= (no value)" >&5
6446 $as_echo "$as_me: Setting user supplied tool DATE= (no value)" >&6;}
6447         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DATE" >&5
6448 $as_echo_n "checking for DATE... " >&6; }
6449         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
6450 $as_echo "disabled" >&6; }
6451       else
6452         # Check if the provided tool contains a complete path.
6453         tool_specified="$DATE"
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 DATE=$tool_basename" >&5
6458 $as_echo "$as_me: Will search for user supplied tool DATE=$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_DATE+:} false; then :
6464   $as_echo_n "(cached) " >&6
6465 else
6466   case $DATE in
6467   [\\/]* | ?:[\\/]*)
6468   ac_cv_path_DATE="$DATE" # 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_DATE="$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 DATE=$ac_cv_path_DATE
6490 if test -n "$DATE"; then
6491   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
6492 $as_echo "$DATE" >&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$DATE" = 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 DATE=$tool_specified" >&5
6505 $as_echo "$as_me: Will use user supplied tool DATE=$tool_specified" >&6;}
6506           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DATE" >&5
6507 $as_echo_n "checking for DATE... " >&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 DATE=$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   fi
6520 
6521 
6522 
6523   if test "x$DATE" = x; then
6524     as_fn_error $? "Could not find required tool for DATE" "$LINENO" 5
6525   fi
6526 
6527 
6528 
6529 
6530 
6531   # Publish this variable in the help.
6532 
6533 
6534   if [ -z "${DIFF+x}" ]; then
6535     # The variable is not set by user, try to locate tool using the code snippet
6536     for ac_prog in gdiff diff
6537 do
6538   # Extract the first word of "$ac_prog", so it can be a program name with args.
6539 set dummy $ac_prog; ac_word=$2
6540 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6541 $as_echo_n "checking for $ac_word... " >&6; }
6542 if ${ac_cv_path_DIFF+:} false; then :
6543   $as_echo_n "(cached) " >&6
6544 else
6545   case $DIFF in
6546   [\\/]* | ?:[\\/]*)
6547   ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
6548   ;;
6549   *)
6550   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6551 for as_dir in $PATH
6552 do
6553   IFS=$as_save_IFS
6554   test -z "$as_dir" && as_dir=.
6555     for ac_exec_ext in '' $ac_executable_extensions; do
6556   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6557     ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
6558     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6559     break 2
6560   fi
6561 done
6562   done
6563 IFS=$as_save_IFS
6564 
6565   ;;
6566 esac
6567 fi
6568 DIFF=$ac_cv_path_DIFF
6569 if test -n "$DIFF"; then
6570   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
6571 $as_echo "$DIFF" >&6; }
6572 else
6573   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6574 $as_echo "no" >&6; }
6575 fi
6576 
6577 
6578   test -n "$DIFF" && break
6579 done
6580 
6581   else
6582     # The variable is set, but is it from the command line or the environment?
6583 
6584     # Try to remove the string !DIFF! from our list.
6585     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DIFF!/}
6586     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6587       # If it failed, the variable was not from the command line. Ignore it,
6588       # but warn the user (except for BASH, which is always set by the calling BASH).
6589       if test "xDIFF" != xBASH; then
6590         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DIFF from the environment. Use command line variables instead." >&5
6591 $as_echo "$as_me: WARNING: Ignoring value of DIFF from the environment. Use command line variables instead." >&2;}
6592       fi
6593       # Try to locate tool using the code snippet
6594       for ac_prog in gdiff diff
6595 do
6596   # Extract the first word of "$ac_prog", so it can be a program name with args.
6597 set dummy $ac_prog; ac_word=$2
6598 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6599 $as_echo_n "checking for $ac_word... " >&6; }
6600 if ${ac_cv_path_DIFF+:} false; then :
6601   $as_echo_n "(cached) " >&6
6602 else
6603   case $DIFF in
6604   [\\/]* | ?:[\\/]*)
6605   ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
6606   ;;
6607   *)
6608   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6609 for as_dir in $PATH
6610 do
6611   IFS=$as_save_IFS
6612   test -z "$as_dir" && as_dir=.
6613     for ac_exec_ext in '' $ac_executable_extensions; do
6614   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6615     ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
6616     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6617     break 2
6618   fi
6619 done
6620   done
6621 IFS=$as_save_IFS
6622 
6623   ;;
6624 esac
6625 fi
6626 DIFF=$ac_cv_path_DIFF
6627 if test -n "$DIFF"; then
6628   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
6629 $as_echo "$DIFF" >&6; }
6630 else
6631   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6632 $as_echo "no" >&6; }
6633 fi
6634 
6635 
6636   test -n "$DIFF" && break
6637 done
6638 
6639     else
6640       # If it succeeded, then it was overridden by the user. We will use it
6641       # for the tool.
6642 
6643       # First remove it from the list of overridden variables, so we can test
6644       # for unknown variables in the end.
6645       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6646 
6647       # Check if we try to supply an empty value
6648       if test "x$DIFF" = x; then
6649         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool DIFF= (no value)" >&5
6650 $as_echo "$as_me: Setting user supplied tool DIFF= (no value)" >&6;}
6651         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIFF" >&5
6652 $as_echo_n "checking for DIFF... " >&6; }
6653         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
6654 $as_echo "disabled" >&6; }
6655       else
6656         # Check if the provided tool contains a complete path.
6657         tool_specified="$DIFF"
6658         tool_basename="${tool_specified##*/}"
6659         if test "x$tool_basename" = "x$tool_specified"; then
6660           # A command without a complete path is provided, search $PATH.
6661           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DIFF=$tool_basename" >&5
6662 $as_echo "$as_me: Will search for user supplied tool DIFF=$tool_basename" >&6;}
6663           # Extract the first word of "$tool_basename", so it can be a program name with args.
6664 set dummy $tool_basename; ac_word=$2
6665 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6666 $as_echo_n "checking for $ac_word... " >&6; }
6667 if ${ac_cv_path_DIFF+:} false; then :
6668   $as_echo_n "(cached) " >&6
6669 else
6670   case $DIFF in
6671   [\\/]* | ?:[\\/]*)
6672   ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
6673   ;;
6674   *)
6675   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6676 for as_dir in $PATH
6677 do
6678   IFS=$as_save_IFS
6679   test -z "$as_dir" && as_dir=.
6680     for ac_exec_ext in '' $ac_executable_extensions; do
6681   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6682     ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
6683     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6684     break 2
6685   fi
6686 done
6687   done
6688 IFS=$as_save_IFS
6689 
6690   ;;
6691 esac
6692 fi
6693 DIFF=$ac_cv_path_DIFF
6694 if test -n "$DIFF"; then
6695   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
6696 $as_echo "$DIFF" >&6; }
6697 else
6698   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6699 $as_echo "no" >&6; }
6700 fi
6701 
6702 
6703           if test "x$DIFF" = x; then
6704             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6705           fi
6706         else
6707           # Otherwise we believe it is a complete path. Use it as it is.
6708           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DIFF=$tool_specified" >&5
6709 $as_echo "$as_me: Will use user supplied tool DIFF=$tool_specified" >&6;}
6710           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIFF" >&5
6711 $as_echo_n "checking for DIFF... " >&6; }
6712           if test ! -x "$tool_specified"; then
6713             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6714 $as_echo "not found" >&6; }
6715             as_fn_error $? "User supplied tool DIFF=$tool_specified does not exist or is not executable" "$LINENO" 5
6716           fi
6717           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6718 $as_echo "$tool_specified" >&6; }
6719         fi
6720       fi
6721     fi
6722 
6723   fi
6724 
6725 
6726 
6727   if test "x$DIFF" = x; then
6728     as_fn_error $? "Could not find required tool for DIFF" "$LINENO" 5
6729   fi
6730 
6731 
6732 
6733 
6734 
6735   # Publish this variable in the help.
6736 
6737 
6738   if [ -z "${DIRNAME+x}" ]; then
6739     # The variable is not set by user, try to locate tool using the code snippet
6740     for ac_prog in dirname
6741 do
6742   # Extract the first word of "$ac_prog", so it can be a program name with args.
6743 set dummy $ac_prog; ac_word=$2
6744 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6745 $as_echo_n "checking for $ac_word... " >&6; }
6746 if ${ac_cv_path_DIRNAME+:} false; then :
6747   $as_echo_n "(cached) " >&6
6748 else
6749   case $DIRNAME in
6750   [\\/]* | ?:[\\/]*)
6751   ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
6752   ;;
6753   *)
6754   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6755 for as_dir in $PATH
6756 do
6757   IFS=$as_save_IFS
6758   test -z "$as_dir" && as_dir=.
6759     for ac_exec_ext in '' $ac_executable_extensions; do
6760   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6761     ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
6762     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6763     break 2
6764   fi
6765 done
6766   done
6767 IFS=$as_save_IFS
6768 
6769   ;;
6770 esac
6771 fi
6772 DIRNAME=$ac_cv_path_DIRNAME
6773 if test -n "$DIRNAME"; then
6774   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
6775 $as_echo "$DIRNAME" >&6; }
6776 else
6777   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6778 $as_echo "no" >&6; }
6779 fi
6780 
6781 
6782   test -n "$DIRNAME" && break
6783 done
6784 
6785   else
6786     # The variable is set, but is it from the command line or the environment?
6787 
6788     # Try to remove the string !DIRNAME! from our list.
6789     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DIRNAME!/}
6790     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6791       # If it failed, the variable was not from the command line. Ignore it,
6792       # but warn the user (except for BASH, which is always set by the calling BASH).
6793       if test "xDIRNAME" != xBASH; then
6794         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DIRNAME from the environment. Use command line variables instead." >&5
6795 $as_echo "$as_me: WARNING: Ignoring value of DIRNAME from the environment. Use command line variables instead." >&2;}
6796       fi
6797       # Try to locate tool using the code snippet
6798       for ac_prog in dirname
6799 do
6800   # Extract the first word of "$ac_prog", so it can be a program name with args.
6801 set dummy $ac_prog; ac_word=$2
6802 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6803 $as_echo_n "checking for $ac_word... " >&6; }
6804 if ${ac_cv_path_DIRNAME+:} false; then :
6805   $as_echo_n "(cached) " >&6
6806 else
6807   case $DIRNAME in
6808   [\\/]* | ?:[\\/]*)
6809   ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
6810   ;;
6811   *)
6812   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6813 for as_dir in $PATH
6814 do
6815   IFS=$as_save_IFS
6816   test -z "$as_dir" && as_dir=.
6817     for ac_exec_ext in '' $ac_executable_extensions; do
6818   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6819     ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
6820     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6821     break 2
6822   fi
6823 done
6824   done
6825 IFS=$as_save_IFS
6826 
6827   ;;
6828 esac
6829 fi
6830 DIRNAME=$ac_cv_path_DIRNAME
6831 if test -n "$DIRNAME"; then
6832   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
6833 $as_echo "$DIRNAME" >&6; }
6834 else
6835   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6836 $as_echo "no" >&6; }
6837 fi
6838 
6839 
6840   test -n "$DIRNAME" && break
6841 done
6842 
6843     else
6844       # If it succeeded, then it was overridden by the user. We will use it
6845       # for the tool.
6846 
6847       # First remove it from the list of overridden variables, so we can test
6848       # for unknown variables in the end.
6849       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6850 
6851       # Check if we try to supply an empty value
6852       if test "x$DIRNAME" = x; then
6853         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool DIRNAME= (no value)" >&5
6854 $as_echo "$as_me: Setting user supplied tool DIRNAME= (no value)" >&6;}
6855         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIRNAME" >&5
6856 $as_echo_n "checking for DIRNAME... " >&6; }
6857         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
6858 $as_echo "disabled" >&6; }
6859       else
6860         # Check if the provided tool contains a complete path.
6861         tool_specified="$DIRNAME"
6862         tool_basename="${tool_specified##*/}"
6863         if test "x$tool_basename" = "x$tool_specified"; then
6864           # A command without a complete path is provided, search $PATH.
6865           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DIRNAME=$tool_basename" >&5
6866 $as_echo "$as_me: Will search for user supplied tool DIRNAME=$tool_basename" >&6;}
6867           # Extract the first word of "$tool_basename", so it can be a program name with args.
6868 set dummy $tool_basename; ac_word=$2
6869 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6870 $as_echo_n "checking for $ac_word... " >&6; }
6871 if ${ac_cv_path_DIRNAME+:} false; then :
6872   $as_echo_n "(cached) " >&6
6873 else
6874   case $DIRNAME in
6875   [\\/]* | ?:[\\/]*)
6876   ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
6877   ;;
6878   *)
6879   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6880 for as_dir in $PATH
6881 do
6882   IFS=$as_save_IFS
6883   test -z "$as_dir" && as_dir=.
6884     for ac_exec_ext in '' $ac_executable_extensions; do
6885   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6886     ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
6887     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6888     break 2
6889   fi
6890 done
6891   done
6892 IFS=$as_save_IFS
6893 
6894   ;;
6895 esac
6896 fi
6897 DIRNAME=$ac_cv_path_DIRNAME
6898 if test -n "$DIRNAME"; then
6899   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
6900 $as_echo "$DIRNAME" >&6; }
6901 else
6902   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6903 $as_echo "no" >&6; }
6904 fi
6905 
6906 
6907           if test "x$DIRNAME" = x; then
6908             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6909           fi
6910         else
6911           # Otherwise we believe it is a complete path. Use it as it is.
6912           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DIRNAME=$tool_specified" >&5
6913 $as_echo "$as_me: Will use user supplied tool DIRNAME=$tool_specified" >&6;}
6914           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIRNAME" >&5
6915 $as_echo_n "checking for DIRNAME... " >&6; }
6916           if test ! -x "$tool_specified"; then
6917             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6918 $as_echo "not found" >&6; }
6919             as_fn_error $? "User supplied tool DIRNAME=$tool_specified does not exist or is not executable" "$LINENO" 5
6920           fi
6921           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6922 $as_echo "$tool_specified" >&6; }
6923         fi
6924       fi
6925     fi
6926 
6927   fi
6928 
6929 
6930 
6931   if test "x$DIRNAME" = x; then
6932     as_fn_error $? "Could not find required tool for DIRNAME" "$LINENO" 5
6933   fi
6934 
6935 
6936 
6937 
6938 
6939   # Publish this variable in the help.
6940 
6941 
6942   if [ -z "${ECHO+x}" ]; then
6943     # The variable is not set by user, try to locate tool using the code snippet
6944     for ac_prog in echo
6945 do
6946   # Extract the first word of "$ac_prog", so it can be a program name with args.
6947 set dummy $ac_prog; ac_word=$2
6948 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6949 $as_echo_n "checking for $ac_word... " >&6; }
6950 if ${ac_cv_path_ECHO+:} false; then :
6951   $as_echo_n "(cached) " >&6
6952 else
6953   case $ECHO in
6954   [\\/]* | ?:[\\/]*)
6955   ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
6956   ;;
6957   *)
6958   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6959 for as_dir in $PATH
6960 do
6961   IFS=$as_save_IFS
6962   test -z "$as_dir" && as_dir=.
6963     for ac_exec_ext in '' $ac_executable_extensions; do
6964   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6965     ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
6966     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6967     break 2
6968   fi
6969 done
6970   done
6971 IFS=$as_save_IFS
6972 
6973   ;;
6974 esac
6975 fi
6976 ECHO=$ac_cv_path_ECHO
6977 if test -n "$ECHO"; then
6978   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
6979 $as_echo "$ECHO" >&6; }
6980 else
6981   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6982 $as_echo "no" >&6; }
6983 fi
6984 
6985 
6986   test -n "$ECHO" && break
6987 done
6988 
6989   else
6990     # The variable is set, but is it from the command line or the environment?
6991 
6992     # Try to remove the string !ECHO! from our list.
6993     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!ECHO!/}
6994     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6995       # If it failed, the variable was not from the command line. Ignore it,
6996       # but warn the user (except for BASH, which is always set by the calling BASH).
6997       if test "xECHO" != xBASH; then
6998         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ECHO from the environment. Use command line variables instead." >&5
6999 $as_echo "$as_me: WARNING: Ignoring value of ECHO from the environment. Use command line variables instead." >&2;}
7000       fi
7001       # Try to locate tool using the code snippet
7002       for ac_prog in echo
7003 do
7004   # Extract the first word of "$ac_prog", so it can be a program name with args.
7005 set dummy $ac_prog; ac_word=$2
7006 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7007 $as_echo_n "checking for $ac_word... " >&6; }
7008 if ${ac_cv_path_ECHO+:} false; then :
7009   $as_echo_n "(cached) " >&6
7010 else
7011   case $ECHO in
7012   [\\/]* | ?:[\\/]*)
7013   ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
7014   ;;
7015   *)
7016   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7017 for as_dir in $PATH
7018 do
7019   IFS=$as_save_IFS
7020   test -z "$as_dir" && as_dir=.
7021     for ac_exec_ext in '' $ac_executable_extensions; do
7022   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7023     ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
7024     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7025     break 2
7026   fi
7027 done
7028   done
7029 IFS=$as_save_IFS
7030 
7031   ;;
7032 esac
7033 fi
7034 ECHO=$ac_cv_path_ECHO
7035 if test -n "$ECHO"; then
7036   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
7037 $as_echo "$ECHO" >&6; }
7038 else
7039   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7040 $as_echo "no" >&6; }
7041 fi
7042 
7043 
7044   test -n "$ECHO" && break
7045 done
7046 
7047     else
7048       # If it succeeded, then it was overridden by the user. We will use it
7049       # for the tool.
7050 
7051       # First remove it from the list of overridden variables, so we can test
7052       # for unknown variables in the end.
7053       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7054 
7055       # Check if we try to supply an empty value
7056       if test "x$ECHO" = x; then
7057         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool ECHO= (no value)" >&5
7058 $as_echo "$as_me: Setting user supplied tool ECHO= (no value)" >&6;}
7059         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ECHO" >&5
7060 $as_echo_n "checking for ECHO... " >&6; }
7061         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
7062 $as_echo "disabled" >&6; }
7063       else
7064         # Check if the provided tool contains a complete path.
7065         tool_specified="$ECHO"
7066         tool_basename="${tool_specified##*/}"
7067         if test "x$tool_basename" = "x$tool_specified"; then
7068           # A command without a complete path is provided, search $PATH.
7069           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ECHO=$tool_basename" >&5
7070 $as_echo "$as_me: Will search for user supplied tool ECHO=$tool_basename" >&6;}
7071           # Extract the first word of "$tool_basename", so it can be a program name with args.
7072 set dummy $tool_basename; ac_word=$2
7073 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7074 $as_echo_n "checking for $ac_word... " >&6; }
7075 if ${ac_cv_path_ECHO+:} false; then :
7076   $as_echo_n "(cached) " >&6
7077 else
7078   case $ECHO in
7079   [\\/]* | ?:[\\/]*)
7080   ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
7081   ;;
7082   *)
7083   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7084 for as_dir in $PATH
7085 do
7086   IFS=$as_save_IFS
7087   test -z "$as_dir" && as_dir=.
7088     for ac_exec_ext in '' $ac_executable_extensions; do
7089   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7090     ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
7091     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7092     break 2
7093   fi
7094 done
7095   done
7096 IFS=$as_save_IFS
7097 
7098   ;;
7099 esac
7100 fi
7101 ECHO=$ac_cv_path_ECHO
7102 if test -n "$ECHO"; then
7103   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
7104 $as_echo "$ECHO" >&6; }
7105 else
7106   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7107 $as_echo "no" >&6; }
7108 fi
7109 
7110 
7111           if test "x$ECHO" = x; then
7112             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7113           fi
7114         else
7115           # Otherwise we believe it is a complete path. Use it as it is.
7116           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ECHO=$tool_specified" >&5
7117 $as_echo "$as_me: Will use user supplied tool ECHO=$tool_specified" >&6;}
7118           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ECHO" >&5
7119 $as_echo_n "checking for ECHO... " >&6; }
7120           if test ! -x "$tool_specified"; then
7121             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7122 $as_echo "not found" >&6; }
7123             as_fn_error $? "User supplied tool ECHO=$tool_specified does not exist or is not executable" "$LINENO" 5
7124           fi
7125           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7126 $as_echo "$tool_specified" >&6; }
7127         fi
7128       fi
7129     fi
7130 
7131   fi
7132 
7133 
7134 
7135   if test "x$ECHO" = x; then
7136     as_fn_error $? "Could not find required tool for ECHO" "$LINENO" 5
7137   fi
7138 
7139 
7140 
7141 
7142 
7143   # Publish this variable in the help.
7144 
7145 
7146   if [ -z "${EXPR+x}" ]; then
7147     # The variable is not set by user, try to locate tool using the code snippet
7148     for ac_prog in expr
7149 do
7150   # Extract the first word of "$ac_prog", so it can be a program name with args.
7151 set dummy $ac_prog; ac_word=$2
7152 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7153 $as_echo_n "checking for $ac_word... " >&6; }
7154 if ${ac_cv_path_EXPR+:} false; then :
7155   $as_echo_n "(cached) " >&6
7156 else
7157   case $EXPR in
7158   [\\/]* | ?:[\\/]*)
7159   ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
7160   ;;
7161   *)
7162   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7163 for as_dir in $PATH
7164 do
7165   IFS=$as_save_IFS
7166   test -z "$as_dir" && as_dir=.
7167     for ac_exec_ext in '' $ac_executable_extensions; do
7168   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7169     ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
7170     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7171     break 2
7172   fi
7173 done
7174   done
7175 IFS=$as_save_IFS
7176 
7177   ;;
7178 esac
7179 fi
7180 EXPR=$ac_cv_path_EXPR
7181 if test -n "$EXPR"; then
7182   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
7183 $as_echo "$EXPR" >&6; }
7184 else
7185   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7186 $as_echo "no" >&6; }
7187 fi
7188 
7189 
7190   test -n "$EXPR" && break
7191 done
7192 
7193   else
7194     # The variable is set, but is it from the command line or the environment?
7195 
7196     # Try to remove the string !EXPR! from our list.
7197     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!EXPR!/}
7198     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7199       # If it failed, the variable was not from the command line. Ignore it,
7200       # but warn the user (except for BASH, which is always set by the calling BASH).
7201       if test "xEXPR" != xBASH; then
7202         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of EXPR from the environment. Use command line variables instead." >&5
7203 $as_echo "$as_me: WARNING: Ignoring value of EXPR from the environment. Use command line variables instead." >&2;}
7204       fi
7205       # Try to locate tool using the code snippet
7206       for ac_prog in expr
7207 do
7208   # Extract the first word of "$ac_prog", so it can be a program name with args.
7209 set dummy $ac_prog; ac_word=$2
7210 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7211 $as_echo_n "checking for $ac_word... " >&6; }
7212 if ${ac_cv_path_EXPR+:} false; then :
7213   $as_echo_n "(cached) " >&6
7214 else
7215   case $EXPR in
7216   [\\/]* | ?:[\\/]*)
7217   ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
7218   ;;
7219   *)
7220   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7221 for as_dir in $PATH
7222 do
7223   IFS=$as_save_IFS
7224   test -z "$as_dir" && as_dir=.
7225     for ac_exec_ext in '' $ac_executable_extensions; do
7226   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7227     ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
7228     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7229     break 2
7230   fi
7231 done
7232   done
7233 IFS=$as_save_IFS
7234 
7235   ;;
7236 esac
7237 fi
7238 EXPR=$ac_cv_path_EXPR
7239 if test -n "$EXPR"; then
7240   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
7241 $as_echo "$EXPR" >&6; }
7242 else
7243   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7244 $as_echo "no" >&6; }
7245 fi
7246 
7247 
7248   test -n "$EXPR" && break
7249 done
7250 
7251     else
7252       # If it succeeded, then it was overridden by the user. We will use it
7253       # for the tool.
7254 
7255       # First remove it from the list of overridden variables, so we can test
7256       # for unknown variables in the end.
7257       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7258 
7259       # Check if we try to supply an empty value
7260       if test "x$EXPR" = x; then
7261         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool EXPR= (no value)" >&5
7262 $as_echo "$as_me: Setting user supplied tool EXPR= (no value)" >&6;}
7263         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EXPR" >&5
7264 $as_echo_n "checking for EXPR... " >&6; }
7265         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
7266 $as_echo "disabled" >&6; }
7267       else
7268         # Check if the provided tool contains a complete path.
7269         tool_specified="$EXPR"
7270         tool_basename="${tool_specified##*/}"
7271         if test "x$tool_basename" = "x$tool_specified"; then
7272           # A command without a complete path is provided, search $PATH.
7273           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool EXPR=$tool_basename" >&5
7274 $as_echo "$as_me: Will search for user supplied tool EXPR=$tool_basename" >&6;}
7275           # Extract the first word of "$tool_basename", so it can be a program name with args.
7276 set dummy $tool_basename; ac_word=$2
7277 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7278 $as_echo_n "checking for $ac_word... " >&6; }
7279 if ${ac_cv_path_EXPR+:} false; then :
7280   $as_echo_n "(cached) " >&6
7281 else
7282   case $EXPR in
7283   [\\/]* | ?:[\\/]*)
7284   ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
7285   ;;
7286   *)
7287   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7288 for as_dir in $PATH
7289 do
7290   IFS=$as_save_IFS
7291   test -z "$as_dir" && as_dir=.
7292     for ac_exec_ext in '' $ac_executable_extensions; do
7293   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7294     ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
7295     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7296     break 2
7297   fi
7298 done
7299   done
7300 IFS=$as_save_IFS
7301 
7302   ;;
7303 esac
7304 fi
7305 EXPR=$ac_cv_path_EXPR
7306 if test -n "$EXPR"; then
7307   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
7308 $as_echo "$EXPR" >&6; }
7309 else
7310   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7311 $as_echo "no" >&6; }
7312 fi
7313 
7314 
7315           if test "x$EXPR" = x; then
7316             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7317           fi
7318         else
7319           # Otherwise we believe it is a complete path. Use it as it is.
7320           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool EXPR=$tool_specified" >&5
7321 $as_echo "$as_me: Will use user supplied tool EXPR=$tool_specified" >&6;}
7322           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EXPR" >&5
7323 $as_echo_n "checking for EXPR... " >&6; }
7324           if test ! -x "$tool_specified"; then
7325             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7326 $as_echo "not found" >&6; }
7327             as_fn_error $? "User supplied tool EXPR=$tool_specified does not exist or is not executable" "$LINENO" 5
7328           fi
7329           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7330 $as_echo "$tool_specified" >&6; }
7331         fi
7332       fi
7333     fi
7334 
7335   fi
7336 
7337 
7338 
7339   if test "x$EXPR" = x; then
7340     as_fn_error $? "Could not find required tool for EXPR" "$LINENO" 5
7341   fi
7342 
7343 
7344 
7345 
7346 
7347   # Publish this variable in the help.
7348 
7349 
7350   if [ -z "${FILE+x}" ]; then
7351     # The variable is not set by user, try to locate tool using the code snippet
7352     for ac_prog in file
7353 do
7354   # Extract the first word of "$ac_prog", so it can be a program name with args.
7355 set dummy $ac_prog; ac_word=$2
7356 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7357 $as_echo_n "checking for $ac_word... " >&6; }
7358 if ${ac_cv_path_FILE+:} false; then :
7359   $as_echo_n "(cached) " >&6
7360 else
7361   case $FILE in
7362   [\\/]* | ?:[\\/]*)
7363   ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
7364   ;;
7365   *)
7366   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7367 for as_dir in $PATH
7368 do
7369   IFS=$as_save_IFS
7370   test -z "$as_dir" && as_dir=.
7371     for ac_exec_ext in '' $ac_executable_extensions; do
7372   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7373     ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
7374     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7375     break 2
7376   fi
7377 done
7378   done
7379 IFS=$as_save_IFS
7380 
7381   ;;
7382 esac
7383 fi
7384 FILE=$ac_cv_path_FILE
7385 if test -n "$FILE"; then
7386   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
7387 $as_echo "$FILE" >&6; }
7388 else
7389   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7390 $as_echo "no" >&6; }
7391 fi
7392 
7393 
7394   test -n "$FILE" && break
7395 done
7396 
7397   else
7398     # The variable is set, but is it from the command line or the environment?
7399 
7400     # Try to remove the string !FILE! from our list.
7401     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FILE!/}
7402     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7403       # If it failed, the variable was not from the command line. Ignore it,
7404       # but warn the user (except for BASH, which is always set by the calling BASH).
7405       if test "xFILE" != xBASH; then
7406         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FILE from the environment. Use command line variables instead." >&5
7407 $as_echo "$as_me: WARNING: Ignoring value of FILE from the environment. Use command line variables instead." >&2;}
7408       fi
7409       # Try to locate tool using the code snippet
7410       for ac_prog in file
7411 do
7412   # Extract the first word of "$ac_prog", so it can be a program name with args.
7413 set dummy $ac_prog; ac_word=$2
7414 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7415 $as_echo_n "checking for $ac_word... " >&6; }
7416 if ${ac_cv_path_FILE+:} false; then :
7417   $as_echo_n "(cached) " >&6
7418 else
7419   case $FILE in
7420   [\\/]* | ?:[\\/]*)
7421   ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
7422   ;;
7423   *)
7424   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7425 for as_dir in $PATH
7426 do
7427   IFS=$as_save_IFS
7428   test -z "$as_dir" && as_dir=.
7429     for ac_exec_ext in '' $ac_executable_extensions; do
7430   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7431     ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
7432     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7433     break 2
7434   fi
7435 done
7436   done
7437 IFS=$as_save_IFS
7438 
7439   ;;
7440 esac
7441 fi
7442 FILE=$ac_cv_path_FILE
7443 if test -n "$FILE"; then
7444   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
7445 $as_echo "$FILE" >&6; }
7446 else
7447   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7448 $as_echo "no" >&6; }
7449 fi
7450 
7451 
7452   test -n "$FILE" && break
7453 done
7454 
7455     else
7456       # If it succeeded, then it was overridden by the user. We will use it
7457       # for the tool.
7458 
7459       # First remove it from the list of overridden variables, so we can test
7460       # for unknown variables in the end.
7461       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7462 
7463       # Check if we try to supply an empty value
7464       if test "x$FILE" = x; then
7465         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool FILE= (no value)" >&5
7466 $as_echo "$as_me: Setting user supplied tool FILE= (no value)" >&6;}
7467         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FILE" >&5
7468 $as_echo_n "checking for FILE... " >&6; }
7469         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
7470 $as_echo "disabled" >&6; }
7471       else
7472         # Check if the provided tool contains a complete path.
7473         tool_specified="$FILE"
7474         tool_basename="${tool_specified##*/}"
7475         if test "x$tool_basename" = "x$tool_specified"; then
7476           # A command without a complete path is provided, search $PATH.
7477           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FILE=$tool_basename" >&5
7478 $as_echo "$as_me: Will search for user supplied tool FILE=$tool_basename" >&6;}
7479           # Extract the first word of "$tool_basename", so it can be a program name with args.
7480 set dummy $tool_basename; ac_word=$2
7481 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7482 $as_echo_n "checking for $ac_word... " >&6; }
7483 if ${ac_cv_path_FILE+:} false; then :
7484   $as_echo_n "(cached) " >&6
7485 else
7486   case $FILE in
7487   [\\/]* | ?:[\\/]*)
7488   ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
7489   ;;
7490   *)
7491   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7492 for as_dir in $PATH
7493 do
7494   IFS=$as_save_IFS
7495   test -z "$as_dir" && as_dir=.
7496     for ac_exec_ext in '' $ac_executable_extensions; do
7497   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7498     ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
7499     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7500     break 2
7501   fi
7502 done
7503   done
7504 IFS=$as_save_IFS
7505 
7506   ;;
7507 esac
7508 fi
7509 FILE=$ac_cv_path_FILE
7510 if test -n "$FILE"; then
7511   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
7512 $as_echo "$FILE" >&6; }
7513 else
7514   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7515 $as_echo "no" >&6; }
7516 fi
7517 
7518 
7519           if test "x$FILE" = x; then
7520             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7521           fi
7522         else
7523           # Otherwise we believe it is a complete path. Use it as it is.
7524           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FILE=$tool_specified" >&5
7525 $as_echo "$as_me: Will use user supplied tool FILE=$tool_specified" >&6;}
7526           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FILE" >&5
7527 $as_echo_n "checking for FILE... " >&6; }
7528           if test ! -x "$tool_specified"; then
7529             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7530 $as_echo "not found" >&6; }
7531             as_fn_error $? "User supplied tool FILE=$tool_specified does not exist or is not executable" "$LINENO" 5
7532           fi
7533           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7534 $as_echo "$tool_specified" >&6; }
7535         fi
7536       fi
7537     fi
7538 
7539   fi
7540 
7541 
7542 
7543   if test "x$FILE" = x; then
7544     as_fn_error $? "Could not find required tool for FILE" "$LINENO" 5
7545   fi
7546 
7547 
7548 
7549 
7550 
7551   # Publish this variable in the help.
7552 
7553 
7554   if [ -z "${FIND+x}" ]; then
7555     # The variable is not set by user, try to locate tool using the code snippet
7556     for ac_prog in find
7557 do
7558   # Extract the first word of "$ac_prog", so it can be a program name with args.
7559 set dummy $ac_prog; ac_word=$2
7560 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7561 $as_echo_n "checking for $ac_word... " >&6; }
7562 if ${ac_cv_path_FIND+:} false; then :
7563   $as_echo_n "(cached) " >&6
7564 else
7565   case $FIND in
7566   [\\/]* | ?:[\\/]*)
7567   ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
7568   ;;
7569   *)
7570   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7571 for as_dir in $PATH
7572 do
7573   IFS=$as_save_IFS
7574   test -z "$as_dir" && as_dir=.
7575     for ac_exec_ext in '' $ac_executable_extensions; do
7576   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7577     ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
7578     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7579     break 2
7580   fi
7581 done
7582   done
7583 IFS=$as_save_IFS
7584 
7585   ;;
7586 esac
7587 fi
7588 FIND=$ac_cv_path_FIND
7589 if test -n "$FIND"; then
7590   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
7591 $as_echo "$FIND" >&6; }
7592 else
7593   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7594 $as_echo "no" >&6; }
7595 fi
7596 
7597 
7598   test -n "$FIND" && break
7599 done
7600 
7601   else
7602     # The variable is set, but is it from the command line or the environment?
7603 
7604     # Try to remove the string !FIND! from our list.
7605     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FIND!/}
7606     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7607       # If it failed, the variable was not from the command line. Ignore it,
7608       # but warn the user (except for BASH, which is always set by the calling BASH).
7609       if test "xFIND" != xBASH; then
7610         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FIND from the environment. Use command line variables instead." >&5
7611 $as_echo "$as_me: WARNING: Ignoring value of FIND from the environment. Use command line variables instead." >&2;}
7612       fi
7613       # Try to locate tool using the code snippet
7614       for ac_prog in find
7615 do
7616   # Extract the first word of "$ac_prog", so it can be a program name with args.
7617 set dummy $ac_prog; ac_word=$2
7618 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7619 $as_echo_n "checking for $ac_word... " >&6; }
7620 if ${ac_cv_path_FIND+:} false; then :
7621   $as_echo_n "(cached) " >&6
7622 else
7623   case $FIND in
7624   [\\/]* | ?:[\\/]*)
7625   ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
7626   ;;
7627   *)
7628   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7629 for as_dir in $PATH
7630 do
7631   IFS=$as_save_IFS
7632   test -z "$as_dir" && as_dir=.
7633     for ac_exec_ext in '' $ac_executable_extensions; do
7634   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7635     ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
7636     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7637     break 2
7638   fi
7639 done
7640   done
7641 IFS=$as_save_IFS
7642 
7643   ;;
7644 esac
7645 fi
7646 FIND=$ac_cv_path_FIND
7647 if test -n "$FIND"; then
7648   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
7649 $as_echo "$FIND" >&6; }
7650 else
7651   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7652 $as_echo "no" >&6; }
7653 fi
7654 
7655 
7656   test -n "$FIND" && break
7657 done
7658 
7659     else
7660       # If it succeeded, then it was overridden by the user. We will use it
7661       # for the tool.
7662 
7663       # First remove it from the list of overridden variables, so we can test
7664       # for unknown variables in the end.
7665       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7666 
7667       # Check if we try to supply an empty value
7668       if test "x$FIND" = x; then
7669         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool FIND= (no value)" >&5
7670 $as_echo "$as_me: Setting user supplied tool FIND= (no value)" >&6;}
7671         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FIND" >&5
7672 $as_echo_n "checking for FIND... " >&6; }
7673         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
7674 $as_echo "disabled" >&6; }
7675       else
7676         # Check if the provided tool contains a complete path.
7677         tool_specified="$FIND"
7678         tool_basename="${tool_specified##*/}"
7679         if test "x$tool_basename" = "x$tool_specified"; then
7680           # A command without a complete path is provided, search $PATH.
7681           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FIND=$tool_basename" >&5
7682 $as_echo "$as_me: Will search for user supplied tool FIND=$tool_basename" >&6;}
7683           # Extract the first word of "$tool_basename", so it can be a program name with args.
7684 set dummy $tool_basename; ac_word=$2
7685 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7686 $as_echo_n "checking for $ac_word... " >&6; }
7687 if ${ac_cv_path_FIND+:} false; then :
7688   $as_echo_n "(cached) " >&6
7689 else
7690   case $FIND in
7691   [\\/]* | ?:[\\/]*)
7692   ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
7693   ;;
7694   *)
7695   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7696 for as_dir in $PATH
7697 do
7698   IFS=$as_save_IFS
7699   test -z "$as_dir" && as_dir=.
7700     for ac_exec_ext in '' $ac_executable_extensions; do
7701   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7702     ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
7703     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7704     break 2
7705   fi
7706 done
7707   done
7708 IFS=$as_save_IFS
7709 
7710   ;;
7711 esac
7712 fi
7713 FIND=$ac_cv_path_FIND
7714 if test -n "$FIND"; then
7715   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
7716 $as_echo "$FIND" >&6; }
7717 else
7718   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7719 $as_echo "no" >&6; }
7720 fi
7721 
7722 
7723           if test "x$FIND" = x; then
7724             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7725           fi
7726         else
7727           # Otherwise we believe it is a complete path. Use it as it is.
7728           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FIND=$tool_specified" >&5
7729 $as_echo "$as_me: Will use user supplied tool FIND=$tool_specified" >&6;}
7730           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FIND" >&5
7731 $as_echo_n "checking for FIND... " >&6; }
7732           if test ! -x "$tool_specified"; then
7733             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7734 $as_echo "not found" >&6; }
7735             as_fn_error $? "User supplied tool FIND=$tool_specified does not exist or is not executable" "$LINENO" 5
7736           fi
7737           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7738 $as_echo "$tool_specified" >&6; }
7739         fi
7740       fi
7741     fi
7742 
7743   fi
7744 
7745 
7746 
7747   if test "x$FIND" = x; then
7748     as_fn_error $? "Could not find required tool for FIND" "$LINENO" 5
7749   fi
7750 
7751 
7752 
7753 
7754 
7755   # Publish this variable in the help.
7756 
7757 
7758   if [ -z "${HEAD+x}" ]; then
7759     # The variable is not set by user, try to locate tool using the code snippet
7760     for ac_prog in head
7761 do
7762   # Extract the first word of "$ac_prog", so it can be a program name with args.
7763 set dummy $ac_prog; ac_word=$2
7764 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7765 $as_echo_n "checking for $ac_word... " >&6; }
7766 if ${ac_cv_path_HEAD+:} false; then :
7767   $as_echo_n "(cached) " >&6
7768 else
7769   case $HEAD in
7770   [\\/]* | ?:[\\/]*)
7771   ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
7772   ;;
7773   *)
7774   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7775 for as_dir in $PATH
7776 do
7777   IFS=$as_save_IFS
7778   test -z "$as_dir" && as_dir=.
7779     for ac_exec_ext in '' $ac_executable_extensions; do
7780   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7781     ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
7782     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7783     break 2
7784   fi
7785 done
7786   done
7787 IFS=$as_save_IFS
7788 
7789   ;;
7790 esac
7791 fi
7792 HEAD=$ac_cv_path_HEAD
7793 if test -n "$HEAD"; then
7794   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
7795 $as_echo "$HEAD" >&6; }
7796 else
7797   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7798 $as_echo "no" >&6; }
7799 fi
7800 
7801 
7802   test -n "$HEAD" && break
7803 done
7804 
7805   else
7806     # The variable is set, but is it from the command line or the environment?
7807 
7808     # Try to remove the string !HEAD! from our list.
7809     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!HEAD!/}
7810     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7811       # If it failed, the variable was not from the command line. Ignore it,
7812       # but warn the user (except for BASH, which is always set by the calling BASH).
7813       if test "xHEAD" != xBASH; then
7814         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of HEAD from the environment. Use command line variables instead." >&5
7815 $as_echo "$as_me: WARNING: Ignoring value of HEAD from the environment. Use command line variables instead." >&2;}
7816       fi
7817       # Try to locate tool using the code snippet
7818       for ac_prog in head
7819 do
7820   # Extract the first word of "$ac_prog", so it can be a program name with args.
7821 set dummy $ac_prog; ac_word=$2
7822 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7823 $as_echo_n "checking for $ac_word... " >&6; }
7824 if ${ac_cv_path_HEAD+:} false; then :
7825   $as_echo_n "(cached) " >&6
7826 else
7827   case $HEAD in
7828   [\\/]* | ?:[\\/]*)
7829   ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
7830   ;;
7831   *)
7832   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7833 for as_dir in $PATH
7834 do
7835   IFS=$as_save_IFS
7836   test -z "$as_dir" && as_dir=.
7837     for ac_exec_ext in '' $ac_executable_extensions; do
7838   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7839     ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
7840     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7841     break 2
7842   fi
7843 done
7844   done
7845 IFS=$as_save_IFS
7846 
7847   ;;
7848 esac
7849 fi
7850 HEAD=$ac_cv_path_HEAD
7851 if test -n "$HEAD"; then
7852   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
7853 $as_echo "$HEAD" >&6; }
7854 else
7855   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7856 $as_echo "no" >&6; }
7857 fi
7858 
7859 
7860   test -n "$HEAD" && break
7861 done
7862 
7863     else
7864       # If it succeeded, then it was overridden by the user. We will use it
7865       # for the tool.
7866 
7867       # First remove it from the list of overridden variables, so we can test
7868       # for unknown variables in the end.
7869       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7870 
7871       # Check if we try to supply an empty value
7872       if test "x$HEAD" = x; then
7873         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool HEAD= (no value)" >&5
7874 $as_echo "$as_me: Setting user supplied tool HEAD= (no value)" >&6;}
7875         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HEAD" >&5
7876 $as_echo_n "checking for HEAD... " >&6; }
7877         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
7878 $as_echo "disabled" >&6; }
7879       else
7880         # Check if the provided tool contains a complete path.
7881         tool_specified="$HEAD"
7882         tool_basename="${tool_specified##*/}"
7883         if test "x$tool_basename" = "x$tool_specified"; then
7884           # A command without a complete path is provided, search $PATH.
7885           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool HEAD=$tool_basename" >&5
7886 $as_echo "$as_me: Will search for user supplied tool HEAD=$tool_basename" >&6;}
7887           # Extract the first word of "$tool_basename", so it can be a program name with args.
7888 set dummy $tool_basename; 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_HEAD+:} false; then :
7892   $as_echo_n "(cached) " >&6
7893 else
7894   case $HEAD in
7895   [\\/]* | ?:[\\/]*)
7896   ac_cv_path_HEAD="$HEAD" # 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_HEAD="$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 HEAD=$ac_cv_path_HEAD
7918 if test -n "$HEAD"; then
7919   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
7920 $as_echo "$HEAD" >&6; }
7921 else
7922   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7923 $as_echo "no" >&6; }
7924 fi
7925 
7926 
7927           if test "x$HEAD" = x; then
7928             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7929           fi
7930         else
7931           # Otherwise we believe it is a complete path. Use it as it is.
7932           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool HEAD=$tool_specified" >&5
7933 $as_echo "$as_me: Will use user supplied tool HEAD=$tool_specified" >&6;}
7934           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HEAD" >&5
7935 $as_echo_n "checking for HEAD... " >&6; }
7936           if test ! -x "$tool_specified"; then
7937             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7938 $as_echo "not found" >&6; }
7939             as_fn_error $? "User supplied tool HEAD=$tool_specified does not exist or is not executable" "$LINENO" 5
7940           fi
7941           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7942 $as_echo "$tool_specified" >&6; }
7943         fi
7944       fi
7945     fi
7946 
7947   fi
7948 
7949 
7950 
7951   if test "x$HEAD" = x; then
7952     as_fn_error $? "Could not find required tool for HEAD" "$LINENO" 5
7953   fi
7954 
7955 
7956 
7957 
7958 
7959   # Publish this variable in the help.
7960 
7961 
7962   if [ -z "${LN+x}" ]; then
7963     # The variable is not set by user, try to locate tool using the code snippet
7964     for ac_prog in ln
7965 do
7966   # Extract the first word of "$ac_prog", so it can be a program name with args.
7967 set dummy $ac_prog; ac_word=$2
7968 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7969 $as_echo_n "checking for $ac_word... " >&6; }
7970 if ${ac_cv_path_LN+:} false; then :
7971   $as_echo_n "(cached) " >&6
7972 else
7973   case $LN in
7974   [\\/]* | ?:[\\/]*)
7975   ac_cv_path_LN="$LN" # Let the user override the test with a path.
7976   ;;
7977   *)
7978   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7979 for as_dir in $PATH
7980 do
7981   IFS=$as_save_IFS
7982   test -z "$as_dir" && as_dir=.
7983     for ac_exec_ext in '' $ac_executable_extensions; do
7984   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7985     ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
7986     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7987     break 2
7988   fi
7989 done
7990   done
7991 IFS=$as_save_IFS
7992 
7993   ;;
7994 esac
7995 fi
7996 LN=$ac_cv_path_LN
7997 if test -n "$LN"; then
7998   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
7999 $as_echo "$LN" >&6; }
8000 else
8001   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8002 $as_echo "no" >&6; }
8003 fi
8004 
8005 
8006   test -n "$LN" && break
8007 done
8008 
8009   else
8010     # The variable is set, but is it from the command line or the environment?
8011 
8012     # Try to remove the string !LN! from our list.
8013     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LN!/}
8014     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8015       # If it failed, the variable was not from the command line. Ignore it,
8016       # but warn the user (except for BASH, which is always set by the calling BASH).
8017       if test "xLN" != xBASH; then
8018         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LN from the environment. Use command line variables instead." >&5
8019 $as_echo "$as_me: WARNING: Ignoring value of LN from the environment. Use command line variables instead." >&2;}
8020       fi
8021       # Try to locate tool using the code snippet
8022       for ac_prog in ln
8023 do
8024   # Extract the first word of "$ac_prog", so it can be a program name with args.
8025 set dummy $ac_prog; ac_word=$2
8026 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8027 $as_echo_n "checking for $ac_word... " >&6; }
8028 if ${ac_cv_path_LN+:} false; then :
8029   $as_echo_n "(cached) " >&6
8030 else
8031   case $LN in
8032   [\\/]* | ?:[\\/]*)
8033   ac_cv_path_LN="$LN" # Let the user override the test with a path.
8034   ;;
8035   *)
8036   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8037 for as_dir in $PATH
8038 do
8039   IFS=$as_save_IFS
8040   test -z "$as_dir" && as_dir=.
8041     for ac_exec_ext in '' $ac_executable_extensions; do
8042   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8043     ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
8044     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8045     break 2
8046   fi
8047 done
8048   done
8049 IFS=$as_save_IFS
8050 
8051   ;;
8052 esac
8053 fi
8054 LN=$ac_cv_path_LN
8055 if test -n "$LN"; then
8056   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
8057 $as_echo "$LN" >&6; }
8058 else
8059   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8060 $as_echo "no" >&6; }
8061 fi
8062 
8063 
8064   test -n "$LN" && break
8065 done
8066 
8067     else
8068       # If it succeeded, then it was overridden by the user. We will use it
8069       # for the tool.
8070 
8071       # First remove it from the list of overridden variables, so we can test
8072       # for unknown variables in the end.
8073       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8074 
8075       # Check if we try to supply an empty value
8076       if test "x$LN" = x; then
8077         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool LN= (no value)" >&5
8078 $as_echo "$as_me: Setting user supplied tool LN= (no value)" >&6;}
8079         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LN" >&5
8080 $as_echo_n "checking for LN... " >&6; }
8081         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
8082 $as_echo "disabled" >&6; }
8083       else
8084         # Check if the provided tool contains a complete path.
8085         tool_specified="$LN"
8086         tool_basename="${tool_specified##*/}"
8087         if test "x$tool_basename" = "x$tool_specified"; then
8088           # A command without a complete path is provided, search $PATH.
8089           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LN=$tool_basename" >&5
8090 $as_echo "$as_me: Will search for user supplied tool LN=$tool_basename" >&6;}
8091           # Extract the first word of "$tool_basename", so it can be a program name with args.
8092 set dummy $tool_basename; ac_word=$2
8093 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8094 $as_echo_n "checking for $ac_word... " >&6; }
8095 if ${ac_cv_path_LN+:} false; then :
8096   $as_echo_n "(cached) " >&6
8097 else
8098   case $LN in
8099   [\\/]* | ?:[\\/]*)
8100   ac_cv_path_LN="$LN" # Let the user override the test with a path.
8101   ;;
8102   *)
8103   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8104 for as_dir in $PATH
8105 do
8106   IFS=$as_save_IFS
8107   test -z "$as_dir" && as_dir=.
8108     for ac_exec_ext in '' $ac_executable_extensions; do
8109   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8110     ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
8111     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8112     break 2
8113   fi
8114 done
8115   done
8116 IFS=$as_save_IFS
8117 
8118   ;;
8119 esac
8120 fi
8121 LN=$ac_cv_path_LN
8122 if test -n "$LN"; then
8123   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
8124 $as_echo "$LN" >&6; }
8125 else
8126   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8127 $as_echo "no" >&6; }
8128 fi
8129 
8130 
8131           if test "x$LN" = x; then
8132             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8133           fi
8134         else
8135           # Otherwise we believe it is a complete path. Use it as it is.
8136           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LN=$tool_specified" >&5
8137 $as_echo "$as_me: Will use user supplied tool LN=$tool_specified" >&6;}
8138           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LN" >&5
8139 $as_echo_n "checking for LN... " >&6; }
8140           if test ! -x "$tool_specified"; then
8141             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8142 $as_echo "not found" >&6; }
8143             as_fn_error $? "User supplied tool LN=$tool_specified does not exist or is not executable" "$LINENO" 5
8144           fi
8145           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8146 $as_echo "$tool_specified" >&6; }
8147         fi
8148       fi
8149     fi
8150 
8151   fi
8152 
8153 
8154 
8155   if test "x$LN" = x; then
8156     as_fn_error $? "Could not find required tool for LN" "$LINENO" 5
8157   fi
8158 
8159 
8160 
8161 
8162 
8163   # Publish this variable in the help.
8164 
8165 
8166   if [ -z "${LS+x}" ]; then
8167     # The variable is not set by user, try to locate tool using the code snippet
8168     for ac_prog in ls
8169 do
8170   # Extract the first word of "$ac_prog", so it can be a program name with args.
8171 set dummy $ac_prog; ac_word=$2
8172 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8173 $as_echo_n "checking for $ac_word... " >&6; }
8174 if ${ac_cv_path_LS+:} false; then :
8175   $as_echo_n "(cached) " >&6
8176 else
8177   case $LS in
8178   [\\/]* | ?:[\\/]*)
8179   ac_cv_path_LS="$LS" # Let the user override the test with a path.
8180   ;;
8181   *)
8182   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8183 for as_dir in $PATH
8184 do
8185   IFS=$as_save_IFS
8186   test -z "$as_dir" && as_dir=.
8187     for ac_exec_ext in '' $ac_executable_extensions; do
8188   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8189     ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
8190     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8191     break 2
8192   fi
8193 done
8194   done
8195 IFS=$as_save_IFS
8196 
8197   ;;
8198 esac
8199 fi
8200 LS=$ac_cv_path_LS
8201 if test -n "$LS"; then
8202   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
8203 $as_echo "$LS" >&6; }
8204 else
8205   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8206 $as_echo "no" >&6; }
8207 fi
8208 
8209 
8210   test -n "$LS" && break
8211 done
8212 
8213   else
8214     # The variable is set, but is it from the command line or the environment?
8215 
8216     # Try to remove the string !LS! from our list.
8217     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LS!/}
8218     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8219       # If it failed, the variable was not from the command line. Ignore it,
8220       # but warn the user (except for BASH, which is always set by the calling BASH).
8221       if test "xLS" != xBASH; then
8222         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LS from the environment. Use command line variables instead." >&5
8223 $as_echo "$as_me: WARNING: Ignoring value of LS from the environment. Use command line variables instead." >&2;}
8224       fi
8225       # Try to locate tool using the code snippet
8226       for ac_prog in ls
8227 do
8228   # Extract the first word of "$ac_prog", so it can be a program name with args.
8229 set dummy $ac_prog; ac_word=$2
8230 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8231 $as_echo_n "checking for $ac_word... " >&6; }
8232 if ${ac_cv_path_LS+:} false; then :
8233   $as_echo_n "(cached) " >&6
8234 else
8235   case $LS in
8236   [\\/]* | ?:[\\/]*)
8237   ac_cv_path_LS="$LS" # Let the user override the test with a path.
8238   ;;
8239   *)
8240   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8241 for as_dir in $PATH
8242 do
8243   IFS=$as_save_IFS
8244   test -z "$as_dir" && as_dir=.
8245     for ac_exec_ext in '' $ac_executable_extensions; do
8246   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8247     ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
8248     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8249     break 2
8250   fi
8251 done
8252   done
8253 IFS=$as_save_IFS
8254 
8255   ;;
8256 esac
8257 fi
8258 LS=$ac_cv_path_LS
8259 if test -n "$LS"; then
8260   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
8261 $as_echo "$LS" >&6; }
8262 else
8263   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8264 $as_echo "no" >&6; }
8265 fi
8266 
8267 
8268   test -n "$LS" && break
8269 done
8270 
8271     else
8272       # If it succeeded, then it was overridden by the user. We will use it
8273       # for the tool.
8274 
8275       # First remove it from the list of overridden variables, so we can test
8276       # for unknown variables in the end.
8277       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8278 
8279       # Check if we try to supply an empty value
8280       if test "x$LS" = x; then
8281         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool LS= (no value)" >&5
8282 $as_echo "$as_me: Setting user supplied tool LS= (no value)" >&6;}
8283         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LS" >&5
8284 $as_echo_n "checking for LS... " >&6; }
8285         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
8286 $as_echo "disabled" >&6; }
8287       else
8288         # Check if the provided tool contains a complete path.
8289         tool_specified="$LS"
8290         tool_basename="${tool_specified##*/}"
8291         if test "x$tool_basename" = "x$tool_specified"; then
8292           # A command without a complete path is provided, search $PATH.
8293           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LS=$tool_basename" >&5
8294 $as_echo "$as_me: Will search for user supplied tool LS=$tool_basename" >&6;}
8295           # Extract the first word of "$tool_basename", so it can be a program name with args.
8296 set dummy $tool_basename; ac_word=$2
8297 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8298 $as_echo_n "checking for $ac_word... " >&6; }
8299 if ${ac_cv_path_LS+:} false; then :
8300   $as_echo_n "(cached) " >&6
8301 else
8302   case $LS in
8303   [\\/]* | ?:[\\/]*)
8304   ac_cv_path_LS="$LS" # Let the user override the test with a path.
8305   ;;
8306   *)
8307   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8308 for as_dir in $PATH
8309 do
8310   IFS=$as_save_IFS
8311   test -z "$as_dir" && as_dir=.
8312     for ac_exec_ext in '' $ac_executable_extensions; do
8313   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8314     ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
8315     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8316     break 2
8317   fi
8318 done
8319   done
8320 IFS=$as_save_IFS
8321 
8322   ;;
8323 esac
8324 fi
8325 LS=$ac_cv_path_LS
8326 if test -n "$LS"; then
8327   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
8328 $as_echo "$LS" >&6; }
8329 else
8330   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8331 $as_echo "no" >&6; }
8332 fi
8333 
8334 
8335           if test "x$LS" = x; then
8336             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8337           fi
8338         else
8339           # Otherwise we believe it is a complete path. Use it as it is.
8340           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LS=$tool_specified" >&5
8341 $as_echo "$as_me: Will use user supplied tool LS=$tool_specified" >&6;}
8342           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LS" >&5
8343 $as_echo_n "checking for LS... " >&6; }
8344           if test ! -x "$tool_specified"; then
8345             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8346 $as_echo "not found" >&6; }
8347             as_fn_error $? "User supplied tool LS=$tool_specified does not exist or is not executable" "$LINENO" 5
8348           fi
8349           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8350 $as_echo "$tool_specified" >&6; }
8351         fi
8352       fi
8353     fi
8354 
8355   fi
8356 
8357 
8358 
8359   if test "x$LS" = x; then
8360     as_fn_error $? "Could not find required tool for LS" "$LINENO" 5
8361   fi
8362 
8363 
8364 
8365 
8366 
8367   # Publish this variable in the help.
8368 
8369 
8370   if [ -z "${MKDIR+x}" ]; then
8371     # The variable is not set by user, try to locate tool using the code snippet
8372     for ac_prog in mkdir
8373 do
8374   # Extract the first word of "$ac_prog", so it can be a program name with args.
8375 set dummy $ac_prog; ac_word=$2
8376 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8377 $as_echo_n "checking for $ac_word... " >&6; }
8378 if ${ac_cv_path_MKDIR+:} false; then :
8379   $as_echo_n "(cached) " >&6
8380 else
8381   case $MKDIR in
8382   [\\/]* | ?:[\\/]*)
8383   ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
8384   ;;
8385   *)
8386   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8387 for as_dir in $PATH
8388 do
8389   IFS=$as_save_IFS
8390   test -z "$as_dir" && as_dir=.
8391     for ac_exec_ext in '' $ac_executable_extensions; do
8392   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8393     ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
8394     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8395     break 2
8396   fi
8397 done
8398   done
8399 IFS=$as_save_IFS
8400 
8401   ;;
8402 esac
8403 fi
8404 MKDIR=$ac_cv_path_MKDIR
8405 if test -n "$MKDIR"; then
8406   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
8407 $as_echo "$MKDIR" >&6; }
8408 else
8409   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8410 $as_echo "no" >&6; }
8411 fi
8412 
8413 
8414   test -n "$MKDIR" && break
8415 done
8416 
8417   else
8418     # The variable is set, but is it from the command line or the environment?
8419 
8420     # Try to remove the string !MKDIR! from our list.
8421     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MKDIR!/}
8422     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8423       # If it failed, the variable was not from the command line. Ignore it,
8424       # but warn the user (except for BASH, which is always set by the calling BASH).
8425       if test "xMKDIR" != xBASH; then
8426         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MKDIR from the environment. Use command line variables instead." >&5
8427 $as_echo "$as_me: WARNING: Ignoring value of MKDIR from the environment. Use command line variables instead." >&2;}
8428       fi
8429       # Try to locate tool using the code snippet
8430       for ac_prog in mkdir
8431 do
8432   # Extract the first word of "$ac_prog", so it can be a program name with args.
8433 set dummy $ac_prog; ac_word=$2
8434 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8435 $as_echo_n "checking for $ac_word... " >&6; }
8436 if ${ac_cv_path_MKDIR+:} false; then :
8437   $as_echo_n "(cached) " >&6
8438 else
8439   case $MKDIR in
8440   [\\/]* | ?:[\\/]*)
8441   ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
8442   ;;
8443   *)
8444   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8445 for as_dir in $PATH
8446 do
8447   IFS=$as_save_IFS
8448   test -z "$as_dir" && as_dir=.
8449     for ac_exec_ext in '' $ac_executable_extensions; do
8450   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8451     ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
8452     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8453     break 2
8454   fi
8455 done
8456   done
8457 IFS=$as_save_IFS
8458 
8459   ;;
8460 esac
8461 fi
8462 MKDIR=$ac_cv_path_MKDIR
8463 if test -n "$MKDIR"; then
8464   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
8465 $as_echo "$MKDIR" >&6; }
8466 else
8467   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8468 $as_echo "no" >&6; }
8469 fi
8470 
8471 
8472   test -n "$MKDIR" && break
8473 done
8474 
8475     else
8476       # If it succeeded, then it was overridden by the user. We will use it
8477       # for the tool.
8478 
8479       # First remove it from the list of overridden variables, so we can test
8480       # for unknown variables in the end.
8481       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8482 
8483       # Check if we try to supply an empty value
8484       if test "x$MKDIR" = x; then
8485         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool MKDIR= (no value)" >&5
8486 $as_echo "$as_me: Setting user supplied tool MKDIR= (no value)" >&6;}
8487         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKDIR" >&5
8488 $as_echo_n "checking for MKDIR... " >&6; }
8489         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
8490 $as_echo "disabled" >&6; }
8491       else
8492         # Check if the provided tool contains a complete path.
8493         tool_specified="$MKDIR"
8494         tool_basename="${tool_specified##*/}"
8495         if test "x$tool_basename" = "x$tool_specified"; then
8496           # A command without a complete path is provided, search $PATH.
8497           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MKDIR=$tool_basename" >&5
8498 $as_echo "$as_me: Will search for user supplied tool MKDIR=$tool_basename" >&6;}
8499           # Extract the first word of "$tool_basename", so it can be a program name with args.
8500 set dummy $tool_basename; ac_word=$2
8501 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8502 $as_echo_n "checking for $ac_word... " >&6; }
8503 if ${ac_cv_path_MKDIR+:} false; then :
8504   $as_echo_n "(cached) " >&6
8505 else
8506   case $MKDIR in
8507   [\\/]* | ?:[\\/]*)
8508   ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
8509   ;;
8510   *)
8511   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8512 for as_dir in $PATH
8513 do
8514   IFS=$as_save_IFS
8515   test -z "$as_dir" && as_dir=.
8516     for ac_exec_ext in '' $ac_executable_extensions; do
8517   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8518     ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
8519     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8520     break 2
8521   fi
8522 done
8523   done
8524 IFS=$as_save_IFS
8525 
8526   ;;
8527 esac
8528 fi
8529 MKDIR=$ac_cv_path_MKDIR
8530 if test -n "$MKDIR"; then
8531   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
8532 $as_echo "$MKDIR" >&6; }
8533 else
8534   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8535 $as_echo "no" >&6; }
8536 fi
8537 
8538 
8539           if test "x$MKDIR" = x; then
8540             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8541           fi
8542         else
8543           # Otherwise we believe it is a complete path. Use it as it is.
8544           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MKDIR=$tool_specified" >&5
8545 $as_echo "$as_me: Will use user supplied tool MKDIR=$tool_specified" >&6;}
8546           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKDIR" >&5
8547 $as_echo_n "checking for MKDIR... " >&6; }
8548           if test ! -x "$tool_specified"; then
8549             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8550 $as_echo "not found" >&6; }
8551             as_fn_error $? "User supplied tool MKDIR=$tool_specified does not exist or is not executable" "$LINENO" 5
8552           fi
8553           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8554 $as_echo "$tool_specified" >&6; }
8555         fi
8556       fi
8557     fi
8558 
8559   fi
8560 
8561 
8562 
8563   if test "x$MKDIR" = x; then
8564     as_fn_error $? "Could not find required tool for MKDIR" "$LINENO" 5
8565   fi
8566 
8567 
8568 
8569 
8570 
8571   # Publish this variable in the help.
8572 
8573 
8574   if [ -z "${MKTEMP+x}" ]; then
8575     # The variable is not set by user, try to locate tool using the code snippet
8576     for ac_prog in mktemp
8577 do
8578   # Extract the first word of "$ac_prog", so it can be a program name with args.
8579 set dummy $ac_prog; ac_word=$2
8580 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8581 $as_echo_n "checking for $ac_word... " >&6; }
8582 if ${ac_cv_path_MKTEMP+:} false; then :
8583   $as_echo_n "(cached) " >&6
8584 else
8585   case $MKTEMP in
8586   [\\/]* | ?:[\\/]*)
8587   ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
8588   ;;
8589   *)
8590   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8591 for as_dir in $PATH
8592 do
8593   IFS=$as_save_IFS
8594   test -z "$as_dir" && as_dir=.
8595     for ac_exec_ext in '' $ac_executable_extensions; do
8596   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8597     ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
8598     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8599     break 2
8600   fi
8601 done
8602   done
8603 IFS=$as_save_IFS
8604 
8605   ;;
8606 esac
8607 fi
8608 MKTEMP=$ac_cv_path_MKTEMP
8609 if test -n "$MKTEMP"; then
8610   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
8611 $as_echo "$MKTEMP" >&6; }
8612 else
8613   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8614 $as_echo "no" >&6; }
8615 fi
8616 
8617 
8618   test -n "$MKTEMP" && break
8619 done
8620 
8621   else
8622     # The variable is set, but is it from the command line or the environment?
8623 
8624     # Try to remove the string !MKTEMP! from our list.
8625     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MKTEMP!/}
8626     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8627       # If it failed, the variable was not from the command line. Ignore it,
8628       # but warn the user (except for BASH, which is always set by the calling BASH).
8629       if test "xMKTEMP" != xBASH; then
8630         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MKTEMP from the environment. Use command line variables instead." >&5
8631 $as_echo "$as_me: WARNING: Ignoring value of MKTEMP from the environment. Use command line variables instead." >&2;}
8632       fi
8633       # Try to locate tool using the code snippet
8634       for ac_prog in mktemp
8635 do
8636   # Extract the first word of "$ac_prog", so it can be a program name with args.
8637 set dummy $ac_prog; ac_word=$2
8638 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8639 $as_echo_n "checking for $ac_word... " >&6; }
8640 if ${ac_cv_path_MKTEMP+:} false; then :
8641   $as_echo_n "(cached) " >&6
8642 else
8643   case $MKTEMP in
8644   [\\/]* | ?:[\\/]*)
8645   ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
8646   ;;
8647   *)
8648   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8649 for as_dir in $PATH
8650 do
8651   IFS=$as_save_IFS
8652   test -z "$as_dir" && as_dir=.
8653     for ac_exec_ext in '' $ac_executable_extensions; do
8654   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8655     ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
8656     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8657     break 2
8658   fi
8659 done
8660   done
8661 IFS=$as_save_IFS
8662 
8663   ;;
8664 esac
8665 fi
8666 MKTEMP=$ac_cv_path_MKTEMP
8667 if test -n "$MKTEMP"; then
8668   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
8669 $as_echo "$MKTEMP" >&6; }
8670 else
8671   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8672 $as_echo "no" >&6; }
8673 fi
8674 
8675 
8676   test -n "$MKTEMP" && break
8677 done
8678 
8679     else
8680       # If it succeeded, then it was overridden by the user. We will use it
8681       # for the tool.
8682 
8683       # First remove it from the list of overridden variables, so we can test
8684       # for unknown variables in the end.
8685       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8686 
8687       # Check if we try to supply an empty value
8688       if test "x$MKTEMP" = x; then
8689         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool MKTEMP= (no value)" >&5
8690 $as_echo "$as_me: Setting user supplied tool MKTEMP= (no value)" >&6;}
8691         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKTEMP" >&5
8692 $as_echo_n "checking for MKTEMP... " >&6; }
8693         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
8694 $as_echo "disabled" >&6; }
8695       else
8696         # Check if the provided tool contains a complete path.
8697         tool_specified="$MKTEMP"
8698         tool_basename="${tool_specified##*/}"
8699         if test "x$tool_basename" = "x$tool_specified"; then
8700           # A command without a complete path is provided, search $PATH.
8701           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MKTEMP=$tool_basename" >&5
8702 $as_echo "$as_me: Will search for user supplied tool MKTEMP=$tool_basename" >&6;}
8703           # Extract the first word of "$tool_basename", so it can be a program name with args.
8704 set dummy $tool_basename; ac_word=$2
8705 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8706 $as_echo_n "checking for $ac_word... " >&6; }
8707 if ${ac_cv_path_MKTEMP+:} false; then :
8708   $as_echo_n "(cached) " >&6
8709 else
8710   case $MKTEMP in
8711   [\\/]* | ?:[\\/]*)
8712   ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
8713   ;;
8714   *)
8715   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8716 for as_dir in $PATH
8717 do
8718   IFS=$as_save_IFS
8719   test -z "$as_dir" && as_dir=.
8720     for ac_exec_ext in '' $ac_executable_extensions; do
8721   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8722     ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
8723     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8724     break 2
8725   fi
8726 done
8727   done
8728 IFS=$as_save_IFS
8729 
8730   ;;
8731 esac
8732 fi
8733 MKTEMP=$ac_cv_path_MKTEMP
8734 if test -n "$MKTEMP"; then
8735   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
8736 $as_echo "$MKTEMP" >&6; }
8737 else
8738   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8739 $as_echo "no" >&6; }
8740 fi
8741 
8742 
8743           if test "x$MKTEMP" = x; then
8744             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8745           fi
8746         else
8747           # Otherwise we believe it is a complete path. Use it as it is.
8748           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MKTEMP=$tool_specified" >&5
8749 $as_echo "$as_me: Will use user supplied tool MKTEMP=$tool_specified" >&6;}
8750           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKTEMP" >&5
8751 $as_echo_n "checking for MKTEMP... " >&6; }
8752           if test ! -x "$tool_specified"; then
8753             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8754 $as_echo "not found" >&6; }
8755             as_fn_error $? "User supplied tool MKTEMP=$tool_specified does not exist or is not executable" "$LINENO" 5
8756           fi
8757           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8758 $as_echo "$tool_specified" >&6; }
8759         fi
8760       fi
8761     fi
8762 
8763   fi
8764 
8765 
8766 
8767   if test "x$MKTEMP" = x; then
8768     as_fn_error $? "Could not find required tool for MKTEMP" "$LINENO" 5
8769   fi
8770 
8771 
8772 
8773 
8774 
8775   # Publish this variable in the help.
8776 
8777 
8778   if [ -z "${MV+x}" ]; then
8779     # The variable is not set by user, try to locate tool using the code snippet
8780     for ac_prog in mv
8781 do
8782   # Extract the first word of "$ac_prog", so it can be a program name with args.
8783 set dummy $ac_prog; ac_word=$2
8784 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8785 $as_echo_n "checking for $ac_word... " >&6; }
8786 if ${ac_cv_path_MV+:} false; then :
8787   $as_echo_n "(cached) " >&6
8788 else
8789   case $MV in
8790   [\\/]* | ?:[\\/]*)
8791   ac_cv_path_MV="$MV" # Let the user override the test with a path.
8792   ;;
8793   *)
8794   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8795 for as_dir in $PATH
8796 do
8797   IFS=$as_save_IFS
8798   test -z "$as_dir" && as_dir=.
8799     for ac_exec_ext in '' $ac_executable_extensions; do
8800   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8801     ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
8802     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8803     break 2
8804   fi
8805 done
8806   done
8807 IFS=$as_save_IFS
8808 
8809   ;;
8810 esac
8811 fi
8812 MV=$ac_cv_path_MV
8813 if test -n "$MV"; then
8814   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
8815 $as_echo "$MV" >&6; }
8816 else
8817   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8818 $as_echo "no" >&6; }
8819 fi
8820 
8821 
8822   test -n "$MV" && break
8823 done
8824 
8825   else
8826     # The variable is set, but is it from the command line or the environment?
8827 
8828     # Try to remove the string !MV! from our list.
8829     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MV!/}
8830     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8831       # If it failed, the variable was not from the command line. Ignore it,
8832       # but warn the user (except for BASH, which is always set by the calling BASH).
8833       if test "xMV" != xBASH; then
8834         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MV from the environment. Use command line variables instead." >&5
8835 $as_echo "$as_me: WARNING: Ignoring value of MV from the environment. Use command line variables instead." >&2;}
8836       fi
8837       # Try to locate tool using the code snippet
8838       for ac_prog in mv
8839 do
8840   # Extract the first word of "$ac_prog", so it can be a program name with args.
8841 set dummy $ac_prog; ac_word=$2
8842 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8843 $as_echo_n "checking for $ac_word... " >&6; }
8844 if ${ac_cv_path_MV+:} false; then :
8845   $as_echo_n "(cached) " >&6
8846 else
8847   case $MV in
8848   [\\/]* | ?:[\\/]*)
8849   ac_cv_path_MV="$MV" # Let the user override the test with a path.
8850   ;;
8851   *)
8852   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8853 for as_dir in $PATH
8854 do
8855   IFS=$as_save_IFS
8856   test -z "$as_dir" && as_dir=.
8857     for ac_exec_ext in '' $ac_executable_extensions; do
8858   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8859     ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
8860     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8861     break 2
8862   fi
8863 done
8864   done
8865 IFS=$as_save_IFS
8866 
8867   ;;
8868 esac
8869 fi
8870 MV=$ac_cv_path_MV
8871 if test -n "$MV"; then
8872   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
8873 $as_echo "$MV" >&6; }
8874 else
8875   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8876 $as_echo "no" >&6; }
8877 fi
8878 
8879 
8880   test -n "$MV" && break
8881 done
8882 
8883     else
8884       # If it succeeded, then it was overridden by the user. We will use it
8885       # for the tool.
8886 
8887       # First remove it from the list of overridden variables, so we can test
8888       # for unknown variables in the end.
8889       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8890 
8891       # Check if we try to supply an empty value
8892       if test "x$MV" = x; then
8893         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool MV= (no value)" >&5
8894 $as_echo "$as_me: Setting user supplied tool MV= (no value)" >&6;}
8895         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MV" >&5
8896 $as_echo_n "checking for MV... " >&6; }
8897         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
8898 $as_echo "disabled" >&6; }
8899       else
8900         # Check if the provided tool contains a complete path.
8901         tool_specified="$MV"
8902         tool_basename="${tool_specified##*/}"
8903         if test "x$tool_basename" = "x$tool_specified"; then
8904           # A command without a complete path is provided, search $PATH.
8905           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MV=$tool_basename" >&5
8906 $as_echo "$as_me: Will search for user supplied tool MV=$tool_basename" >&6;}
8907           # Extract the first word of "$tool_basename", so it can be a program name with args.
8908 set dummy $tool_basename; ac_word=$2
8909 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8910 $as_echo_n "checking for $ac_word... " >&6; }
8911 if ${ac_cv_path_MV+:} false; then :
8912   $as_echo_n "(cached) " >&6
8913 else
8914   case $MV in
8915   [\\/]* | ?:[\\/]*)
8916   ac_cv_path_MV="$MV" # Let the user override the test with a path.
8917   ;;
8918   *)
8919   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8920 for as_dir in $PATH
8921 do
8922   IFS=$as_save_IFS
8923   test -z "$as_dir" && as_dir=.
8924     for ac_exec_ext in '' $ac_executable_extensions; do
8925   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8926     ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
8927     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8928     break 2
8929   fi
8930 done
8931   done
8932 IFS=$as_save_IFS
8933 
8934   ;;
8935 esac
8936 fi
8937 MV=$ac_cv_path_MV
8938 if test -n "$MV"; then
8939   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
8940 $as_echo "$MV" >&6; }
8941 else
8942   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8943 $as_echo "no" >&6; }
8944 fi
8945 
8946 
8947           if test "x$MV" = x; then
8948             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8949           fi
8950         else
8951           # Otherwise we believe it is a complete path. Use it as it is.
8952           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MV=$tool_specified" >&5
8953 $as_echo "$as_me: Will use user supplied tool MV=$tool_specified" >&6;}
8954           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MV" >&5
8955 $as_echo_n "checking for MV... " >&6; }
8956           if test ! -x "$tool_specified"; then
8957             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8958 $as_echo "not found" >&6; }
8959             as_fn_error $? "User supplied tool MV=$tool_specified does not exist or is not executable" "$LINENO" 5
8960           fi
8961           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8962 $as_echo "$tool_specified" >&6; }
8963         fi
8964       fi
8965     fi
8966 
8967   fi
8968 
8969 
8970 
8971   if test "x$MV" = x; then
8972     as_fn_error $? "Could not find required tool for MV" "$LINENO" 5
8973   fi
8974 
8975 
8976 
8977 
8978 
8979   # Publish this variable in the help.
8980 
8981 
8982   if [ -z "${NAWK+x}" ]; then
8983     # The variable is not set by user, try to locate tool using the code snippet
8984     for ac_prog in nawk gawk awk
8985 do
8986   # Extract the first word of "$ac_prog", so it can be a program name with args.
8987 set dummy $ac_prog; ac_word=$2
8988 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8989 $as_echo_n "checking for $ac_word... " >&6; }
8990 if ${ac_cv_path_NAWK+:} false; then :
8991   $as_echo_n "(cached) " >&6
8992 else
8993   case $NAWK in
8994   [\\/]* | ?:[\\/]*)
8995   ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
8996   ;;
8997   *)
8998   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8999 for as_dir in $PATH
9000 do
9001   IFS=$as_save_IFS
9002   test -z "$as_dir" && as_dir=.
9003     for ac_exec_ext in '' $ac_executable_extensions; do
9004   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9005     ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
9006     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9007     break 2
9008   fi
9009 done
9010   done
9011 IFS=$as_save_IFS
9012 
9013   ;;
9014 esac
9015 fi
9016 NAWK=$ac_cv_path_NAWK
9017 if test -n "$NAWK"; then
9018   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
9019 $as_echo "$NAWK" >&6; }
9020 else
9021   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9022 $as_echo "no" >&6; }
9023 fi
9024 
9025 
9026   test -n "$NAWK" && break
9027 done
9028 
9029   else
9030     # The variable is set, but is it from the command line or the environment?
9031 
9032     # Try to remove the string !NAWK! from our list.
9033     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!NAWK!/}
9034     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9035       # If it failed, the variable was not from the command line. Ignore it,
9036       # but warn the user (except for BASH, which is always set by the calling BASH).
9037       if test "xNAWK" != xBASH; then
9038         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of NAWK from the environment. Use command line variables instead." >&5
9039 $as_echo "$as_me: WARNING: Ignoring value of NAWK from the environment. Use command line variables instead." >&2;}
9040       fi
9041       # Try to locate tool using the code snippet
9042       for ac_prog in nawk gawk awk
9043 do
9044   # Extract the first word of "$ac_prog", so it can be a program name with args.
9045 set dummy $ac_prog; ac_word=$2
9046 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9047 $as_echo_n "checking for $ac_word... " >&6; }
9048 if ${ac_cv_path_NAWK+:} false; then :
9049   $as_echo_n "(cached) " >&6
9050 else
9051   case $NAWK in
9052   [\\/]* | ?:[\\/]*)
9053   ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
9054   ;;
9055   *)
9056   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9057 for as_dir in $PATH
9058 do
9059   IFS=$as_save_IFS
9060   test -z "$as_dir" && as_dir=.
9061     for ac_exec_ext in '' $ac_executable_extensions; do
9062   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9063     ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
9064     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9065     break 2
9066   fi
9067 done
9068   done
9069 IFS=$as_save_IFS
9070 
9071   ;;
9072 esac
9073 fi
9074 NAWK=$ac_cv_path_NAWK
9075 if test -n "$NAWK"; then
9076   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
9077 $as_echo "$NAWK" >&6; }
9078 else
9079   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9080 $as_echo "no" >&6; }
9081 fi
9082 
9083 
9084   test -n "$NAWK" && break
9085 done
9086 
9087     else
9088       # If it succeeded, then it was overridden by the user. We will use it
9089       # for the tool.
9090 
9091       # First remove it from the list of overridden variables, so we can test
9092       # for unknown variables in the end.
9093       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9094 
9095       # Check if we try to supply an empty value
9096       if test "x$NAWK" = x; then
9097         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool NAWK= (no value)" >&5
9098 $as_echo "$as_me: Setting user supplied tool NAWK= (no value)" >&6;}
9099         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NAWK" >&5
9100 $as_echo_n "checking for NAWK... " >&6; }
9101         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
9102 $as_echo "disabled" >&6; }
9103       else
9104         # Check if the provided tool contains a complete path.
9105         tool_specified="$NAWK"
9106         tool_basename="${tool_specified##*/}"
9107         if test "x$tool_basename" = "x$tool_specified"; then
9108           # A command without a complete path is provided, search $PATH.
9109           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool NAWK=$tool_basename" >&5
9110 $as_echo "$as_me: Will search for user supplied tool NAWK=$tool_basename" >&6;}
9111           # Extract the first word of "$tool_basename", so it can be a program name with args.
9112 set dummy $tool_basename; ac_word=$2
9113 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9114 $as_echo_n "checking for $ac_word... " >&6; }
9115 if ${ac_cv_path_NAWK+:} false; then :
9116   $as_echo_n "(cached) " >&6
9117 else
9118   case $NAWK in
9119   [\\/]* | ?:[\\/]*)
9120   ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
9121   ;;
9122   *)
9123   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9124 for as_dir in $PATH
9125 do
9126   IFS=$as_save_IFS
9127   test -z "$as_dir" && as_dir=.
9128     for ac_exec_ext in '' $ac_executable_extensions; do
9129   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9130     ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
9131     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9132     break 2
9133   fi
9134 done
9135   done
9136 IFS=$as_save_IFS
9137 
9138   ;;
9139 esac
9140 fi
9141 NAWK=$ac_cv_path_NAWK
9142 if test -n "$NAWK"; then
9143   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
9144 $as_echo "$NAWK" >&6; }
9145 else
9146   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9147 $as_echo "no" >&6; }
9148 fi
9149 
9150 
9151           if test "x$NAWK" = x; then
9152             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9153           fi
9154         else
9155           # Otherwise we believe it is a complete path. Use it as it is.
9156           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool NAWK=$tool_specified" >&5
9157 $as_echo "$as_me: Will use user supplied tool NAWK=$tool_specified" >&6;}
9158           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NAWK" >&5
9159 $as_echo_n "checking for NAWK... " >&6; }
9160           if test ! -x "$tool_specified"; then
9161             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9162 $as_echo "not found" >&6; }
9163             as_fn_error $? "User supplied tool NAWK=$tool_specified does not exist or is not executable" "$LINENO" 5
9164           fi
9165           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9166 $as_echo "$tool_specified" >&6; }
9167         fi
9168       fi
9169     fi
9170 
9171   fi
9172 
9173 
9174 
9175   if test "x$NAWK" = x; then
9176     as_fn_error $? "Could not find required tool for NAWK" "$LINENO" 5
9177   fi
9178 
9179 
9180 
9181 
9182 
9183   # Publish this variable in the help.
9184 
9185 
9186   if [ -z "${PRINTF+x}" ]; then
9187     # The variable is not set by user, try to locate tool using the code snippet
9188     for ac_prog in printf
9189 do
9190   # Extract the first word of "$ac_prog", so it can be a program name with args.
9191 set dummy $ac_prog; ac_word=$2
9192 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9193 $as_echo_n "checking for $ac_word... " >&6; }
9194 if ${ac_cv_path_PRINTF+:} false; then :
9195   $as_echo_n "(cached) " >&6
9196 else
9197   case $PRINTF in
9198   [\\/]* | ?:[\\/]*)
9199   ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
9200   ;;
9201   *)
9202   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9203 for as_dir in $PATH
9204 do
9205   IFS=$as_save_IFS
9206   test -z "$as_dir" && as_dir=.
9207     for ac_exec_ext in '' $ac_executable_extensions; do
9208   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9209     ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
9210     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9211     break 2
9212   fi
9213 done
9214   done
9215 IFS=$as_save_IFS
9216 
9217   ;;
9218 esac
9219 fi
9220 PRINTF=$ac_cv_path_PRINTF
9221 if test -n "$PRINTF"; then
9222   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
9223 $as_echo "$PRINTF" >&6; }
9224 else
9225   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9226 $as_echo "no" >&6; }
9227 fi
9228 
9229 
9230   test -n "$PRINTF" && break
9231 done
9232 
9233   else
9234     # The variable is set, but is it from the command line or the environment?
9235 
9236     # Try to remove the string !PRINTF! from our list.
9237     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!PRINTF!/}
9238     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9239       # If it failed, the variable was not from the command line. Ignore it,
9240       # but warn the user (except for BASH, which is always set by the calling BASH).
9241       if test "xPRINTF" != xBASH; then
9242         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of PRINTF from the environment. Use command line variables instead." >&5
9243 $as_echo "$as_me: WARNING: Ignoring value of PRINTF from the environment. Use command line variables instead." >&2;}
9244       fi
9245       # Try to locate tool using the code snippet
9246       for ac_prog in printf
9247 do
9248   # Extract the first word of "$ac_prog", so it can be a program name with args.
9249 set dummy $ac_prog; ac_word=$2
9250 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9251 $as_echo_n "checking for $ac_word... " >&6; }
9252 if ${ac_cv_path_PRINTF+:} false; then :
9253   $as_echo_n "(cached) " >&6
9254 else
9255   case $PRINTF in
9256   [\\/]* | ?:[\\/]*)
9257   ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
9258   ;;
9259   *)
9260   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9261 for as_dir in $PATH
9262 do
9263   IFS=$as_save_IFS
9264   test -z "$as_dir" && as_dir=.
9265     for ac_exec_ext in '' $ac_executable_extensions; do
9266   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9267     ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
9268     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9269     break 2
9270   fi
9271 done
9272   done
9273 IFS=$as_save_IFS
9274 
9275   ;;
9276 esac
9277 fi
9278 PRINTF=$ac_cv_path_PRINTF
9279 if test -n "$PRINTF"; then
9280   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
9281 $as_echo "$PRINTF" >&6; }
9282 else
9283   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9284 $as_echo "no" >&6; }
9285 fi
9286 
9287 
9288   test -n "$PRINTF" && break
9289 done
9290 
9291     else
9292       # If it succeeded, then it was overridden by the user. We will use it
9293       # for the tool.
9294 
9295       # First remove it from the list of overridden variables, so we can test
9296       # for unknown variables in the end.
9297       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9298 
9299       # Check if we try to supply an empty value
9300       if test "x$PRINTF" = x; then
9301         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool PRINTF= (no value)" >&5
9302 $as_echo "$as_me: Setting user supplied tool PRINTF= (no value)" >&6;}
9303         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PRINTF" >&5
9304 $as_echo_n "checking for PRINTF... " >&6; }
9305         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
9306 $as_echo "disabled" >&6; }
9307       else
9308         # Check if the provided tool contains a complete path.
9309         tool_specified="$PRINTF"
9310         tool_basename="${tool_specified##*/}"
9311         if test "x$tool_basename" = "x$tool_specified"; then
9312           # A command without a complete path is provided, search $PATH.
9313           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool PRINTF=$tool_basename" >&5
9314 $as_echo "$as_me: Will search for user supplied tool PRINTF=$tool_basename" >&6;}
9315           # Extract the first word of "$tool_basename", so it can be a program name with args.
9316 set dummy $tool_basename; ac_word=$2
9317 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9318 $as_echo_n "checking for $ac_word... " >&6; }
9319 if ${ac_cv_path_PRINTF+:} false; then :
9320   $as_echo_n "(cached) " >&6
9321 else
9322   case $PRINTF in
9323   [\\/]* | ?:[\\/]*)
9324   ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
9325   ;;
9326   *)
9327   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9328 for as_dir in $PATH
9329 do
9330   IFS=$as_save_IFS
9331   test -z "$as_dir" && as_dir=.
9332     for ac_exec_ext in '' $ac_executable_extensions; do
9333   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9334     ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
9335     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9336     break 2
9337   fi
9338 done
9339   done
9340 IFS=$as_save_IFS
9341 
9342   ;;
9343 esac
9344 fi
9345 PRINTF=$ac_cv_path_PRINTF
9346 if test -n "$PRINTF"; then
9347   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
9348 $as_echo "$PRINTF" >&6; }
9349 else
9350   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9351 $as_echo "no" >&6; }
9352 fi
9353 
9354 
9355           if test "x$PRINTF" = x; then
9356             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9357           fi
9358         else
9359           # Otherwise we believe it is a complete path. Use it as it is.
9360           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool PRINTF=$tool_specified" >&5
9361 $as_echo "$as_me: Will use user supplied tool PRINTF=$tool_specified" >&6;}
9362           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PRINTF" >&5
9363 $as_echo_n "checking for PRINTF... " >&6; }
9364           if test ! -x "$tool_specified"; then
9365             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9366 $as_echo "not found" >&6; }
9367             as_fn_error $? "User supplied tool PRINTF=$tool_specified does not exist or is not executable" "$LINENO" 5
9368           fi
9369           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9370 $as_echo "$tool_specified" >&6; }
9371         fi
9372       fi
9373     fi
9374 
9375   fi
9376 
9377 
9378 
9379   if test "x$PRINTF" = x; then
9380     as_fn_error $? "Could not find required tool for PRINTF" "$LINENO" 5
9381   fi
9382 
9383 
9384 
9385 
9386 
9387   # Publish this variable in the help.
9388 
9389 
9390   if [ -z "${RM+x}" ]; then
9391     # The variable is not set by user, try to locate tool using the code snippet
9392     for ac_prog in rm
9393 do
9394   # Extract the first word of "$ac_prog", so it can be a program name with args.
9395 set dummy $ac_prog; ac_word=$2
9396 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9397 $as_echo_n "checking for $ac_word... " >&6; }
9398 if ${ac_cv_path_RM+:} false; then :
9399   $as_echo_n "(cached) " >&6
9400 else
9401   case $RM in
9402   [\\/]* | ?:[\\/]*)
9403   ac_cv_path_RM="$RM" # Let the user override the test with a path.
9404   ;;
9405   *)
9406   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9407 for as_dir in $PATH
9408 do
9409   IFS=$as_save_IFS
9410   test -z "$as_dir" && as_dir=.
9411     for ac_exec_ext in '' $ac_executable_extensions; do
9412   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9413     ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
9414     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9415     break 2
9416   fi
9417 done
9418   done
9419 IFS=$as_save_IFS
9420 
9421   ;;
9422 esac
9423 fi
9424 RM=$ac_cv_path_RM
9425 if test -n "$RM"; then
9426   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
9427 $as_echo "$RM" >&6; }
9428 else
9429   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9430 $as_echo "no" >&6; }
9431 fi
9432 
9433 
9434   test -n "$RM" && break
9435 done
9436 
9437   else
9438     # The variable is set, but is it from the command line or the environment?
9439 
9440     # Try to remove the string !RM! from our list.
9441     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!RM!/}
9442     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9443       # If it failed, the variable was not from the command line. Ignore it,
9444       # but warn the user (except for BASH, which is always set by the calling BASH).
9445       if test "xRM" != xBASH; then
9446         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of RM from the environment. Use command line variables instead." >&5
9447 $as_echo "$as_me: WARNING: Ignoring value of RM from the environment. Use command line variables instead." >&2;}
9448       fi
9449       # Try to locate tool using the code snippet
9450       for ac_prog in rm
9451 do
9452   # Extract the first word of "$ac_prog", so it can be a program name with args.
9453 set dummy $ac_prog; ac_word=$2
9454 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9455 $as_echo_n "checking for $ac_word... " >&6; }
9456 if ${ac_cv_path_RM+:} false; then :
9457   $as_echo_n "(cached) " >&6
9458 else
9459   case $RM in
9460   [\\/]* | ?:[\\/]*)
9461   ac_cv_path_RM="$RM" # Let the user override the test with a path.
9462   ;;
9463   *)
9464   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9465 for as_dir in $PATH
9466 do
9467   IFS=$as_save_IFS
9468   test -z "$as_dir" && as_dir=.
9469     for ac_exec_ext in '' $ac_executable_extensions; do
9470   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9471     ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
9472     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9473     break 2
9474   fi
9475 done
9476   done
9477 IFS=$as_save_IFS
9478 
9479   ;;
9480 esac
9481 fi
9482 RM=$ac_cv_path_RM
9483 if test -n "$RM"; then
9484   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
9485 $as_echo "$RM" >&6; }
9486 else
9487   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9488 $as_echo "no" >&6; }
9489 fi
9490 
9491 
9492   test -n "$RM" && break
9493 done
9494 
9495     else
9496       # If it succeeded, then it was overridden by the user. We will use it
9497       # for the tool.
9498 
9499       # First remove it from the list of overridden variables, so we can test
9500       # for unknown variables in the end.
9501       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9502 
9503       # Check if we try to supply an empty value
9504       if test "x$RM" = x; then
9505         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool RM= (no value)" >&5
9506 $as_echo "$as_me: Setting user supplied tool RM= (no value)" >&6;}
9507         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for RM" >&5
9508 $as_echo_n "checking for RM... " >&6; }
9509         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
9510 $as_echo "disabled" >&6; }
9511       else
9512         # Check if the provided tool contains a complete path.
9513         tool_specified="$RM"
9514         tool_basename="${tool_specified##*/}"
9515         if test "x$tool_basename" = "x$tool_specified"; then
9516           # A command without a complete path is provided, search $PATH.
9517           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool RM=$tool_basename" >&5
9518 $as_echo "$as_me: Will search for user supplied tool RM=$tool_basename" >&6;}
9519           # Extract the first word of "$tool_basename", so it can be a program name with args.
9520 set dummy $tool_basename; ac_word=$2
9521 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9522 $as_echo_n "checking for $ac_word... " >&6; }
9523 if ${ac_cv_path_RM+:} false; then :
9524   $as_echo_n "(cached) " >&6
9525 else
9526   case $RM in
9527   [\\/]* | ?:[\\/]*)
9528   ac_cv_path_RM="$RM" # Let the user override the test with a path.
9529   ;;
9530   *)
9531   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9532 for as_dir in $PATH
9533 do
9534   IFS=$as_save_IFS
9535   test -z "$as_dir" && as_dir=.
9536     for ac_exec_ext in '' $ac_executable_extensions; do
9537   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9538     ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
9539     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9540     break 2
9541   fi
9542 done
9543   done
9544 IFS=$as_save_IFS
9545 
9546   ;;
9547 esac
9548 fi
9549 RM=$ac_cv_path_RM
9550 if test -n "$RM"; then
9551   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
9552 $as_echo "$RM" >&6; }
9553 else
9554   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9555 $as_echo "no" >&6; }
9556 fi
9557 
9558 
9559           if test "x$RM" = x; then
9560             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9561           fi
9562         else
9563           # Otherwise we believe it is a complete path. Use it as it is.
9564           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool RM=$tool_specified" >&5
9565 $as_echo "$as_me: Will use user supplied tool RM=$tool_specified" >&6;}
9566           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for RM" >&5
9567 $as_echo_n "checking for RM... " >&6; }
9568           if test ! -x "$tool_specified"; then
9569             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9570 $as_echo "not found" >&6; }
9571             as_fn_error $? "User supplied tool RM=$tool_specified does not exist or is not executable" "$LINENO" 5
9572           fi
9573           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9574 $as_echo "$tool_specified" >&6; }
9575         fi
9576       fi
9577     fi
9578 
9579   fi
9580 
9581 
9582 
9583   if test "x$RM" = x; then
9584     as_fn_error $? "Could not find required tool for RM" "$LINENO" 5
9585   fi
9586 
9587 
9588 
9589 
9590 
9591   # Publish this variable in the help.
9592 
9593 
9594   if [ -z "${RMDIR+x}" ]; then
9595     # The variable is not set by user, try to locate tool using the code snippet
9596     for ac_prog in rmdir
9597 do
9598   # Extract the first word of "$ac_prog", so it can be a program name with args.
9599 set dummy $ac_prog; ac_word=$2
9600 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9601 $as_echo_n "checking for $ac_word... " >&6; }
9602 if ${ac_cv_path_RMDIR+:} false; then :
9603   $as_echo_n "(cached) " >&6
9604 else
9605   case $RMDIR in
9606   [\\/]* | ?:[\\/]*)
9607   ac_cv_path_RMDIR="$RMDIR" # Let the user override the test with a path.
9608   ;;
9609   *)
9610   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9611 for as_dir in $PATH
9612 do
9613   IFS=$as_save_IFS
9614   test -z "$as_dir" && as_dir=.
9615     for ac_exec_ext in '' $ac_executable_extensions; do
9616   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9617     ac_cv_path_RMDIR="$as_dir/$ac_word$ac_exec_ext"
9618     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9619     break 2
9620   fi
9621 done
9622   done
9623 IFS=$as_save_IFS
9624 
9625   ;;
9626 esac
9627 fi
9628 RMDIR=$ac_cv_path_RMDIR
9629 if test -n "$RMDIR"; then
9630   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RMDIR" >&5
9631 $as_echo "$RMDIR" >&6; }
9632 else
9633   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9634 $as_echo "no" >&6; }
9635 fi
9636 
9637 
9638   test -n "$RMDIR" && break
9639 done
9640 
9641   else
9642     # The variable is set, but is it from the command line or the environment?
9643 
9644     # Try to remove the string !RMDIR! from our list.
9645     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!RMDIR!/}
9646     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9647       # If it failed, the variable was not from the command line. Ignore it,
9648       # but warn the user (except for BASH, which is always set by the calling BASH).
9649       if test "xRMDIR" != xBASH; then
9650         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of RMDIR from the environment. Use command line variables instead." >&5
9651 $as_echo "$as_me: WARNING: Ignoring value of RMDIR from the environment. Use command line variables instead." >&2;}
9652       fi
9653       # Try to locate tool using the code snippet
9654       for ac_prog in rmdir
9655 do
9656   # Extract the first word of "$ac_prog", so it can be a program name with args.
9657 set dummy $ac_prog; ac_word=$2
9658 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9659 $as_echo_n "checking for $ac_word... " >&6; }
9660 if ${ac_cv_path_RMDIR+:} false; then :
9661   $as_echo_n "(cached) " >&6
9662 else
9663   case $RMDIR in
9664   [\\/]* | ?:[\\/]*)
9665   ac_cv_path_RMDIR="$RMDIR" # Let the user override the test with a path.
9666   ;;
9667   *)
9668   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9669 for as_dir in $PATH
9670 do
9671   IFS=$as_save_IFS
9672   test -z "$as_dir" && as_dir=.
9673     for ac_exec_ext in '' $ac_executable_extensions; do
9674   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9675     ac_cv_path_RMDIR="$as_dir/$ac_word$ac_exec_ext"
9676     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9677     break 2
9678   fi
9679 done
9680   done
9681 IFS=$as_save_IFS
9682 
9683   ;;
9684 esac
9685 fi
9686 RMDIR=$ac_cv_path_RMDIR
9687 if test -n "$RMDIR"; then
9688   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RMDIR" >&5
9689 $as_echo "$RMDIR" >&6; }
9690 else
9691   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9692 $as_echo "no" >&6; }
9693 fi
9694 
9695 
9696   test -n "$RMDIR" && break
9697 done
9698 
9699     else
9700       # If it succeeded, then it was overridden by the user. We will use it
9701       # for the tool.
9702 
9703       # First remove it from the list of overridden variables, so we can test
9704       # for unknown variables in the end.
9705       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9706 
9707       # Check if we try to supply an empty value
9708       if test "x$RMDIR" = x; then
9709         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool RMDIR= (no value)" >&5
9710 $as_echo "$as_me: Setting user supplied tool RMDIR= (no value)" >&6;}
9711         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for RMDIR" >&5
9712 $as_echo_n "checking for RMDIR... " >&6; }
9713         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
9714 $as_echo "disabled" >&6; }
9715       else
9716         # Check if the provided tool contains a complete path.
9717         tool_specified="$RMDIR"
9718         tool_basename="${tool_specified##*/}"
9719         if test "x$tool_basename" = "x$tool_specified"; then
9720           # A command without a complete path is provided, search $PATH.
9721           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool RMDIR=$tool_basename" >&5
9722 $as_echo "$as_me: Will search for user supplied tool RMDIR=$tool_basename" >&6;}
9723           # Extract the first word of "$tool_basename", so it can be a program name with args.
9724 set dummy $tool_basename; ac_word=$2
9725 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9726 $as_echo_n "checking for $ac_word... " >&6; }
9727 if ${ac_cv_path_RMDIR+:} false; then :
9728   $as_echo_n "(cached) " >&6
9729 else
9730   case $RMDIR in
9731   [\\/]* | ?:[\\/]*)
9732   ac_cv_path_RMDIR="$RMDIR" # Let the user override the test with a path.
9733   ;;
9734   *)
9735   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9736 for as_dir in $PATH
9737 do
9738   IFS=$as_save_IFS
9739   test -z "$as_dir" && as_dir=.
9740     for ac_exec_ext in '' $ac_executable_extensions; do
9741   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9742     ac_cv_path_RMDIR="$as_dir/$ac_word$ac_exec_ext"
9743     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9744     break 2
9745   fi
9746 done
9747   done
9748 IFS=$as_save_IFS
9749 
9750   ;;
9751 esac
9752 fi
9753 RMDIR=$ac_cv_path_RMDIR
9754 if test -n "$RMDIR"; then
9755   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RMDIR" >&5
9756 $as_echo "$RMDIR" >&6; }
9757 else
9758   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9759 $as_echo "no" >&6; }
9760 fi
9761 
9762 
9763           if test "x$RMDIR" = x; then
9764             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9765           fi
9766         else
9767           # Otherwise we believe it is a complete path. Use it as it is.
9768           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool RMDIR=$tool_specified" >&5
9769 $as_echo "$as_me: Will use user supplied tool RMDIR=$tool_specified" >&6;}
9770           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for RMDIR" >&5
9771 $as_echo_n "checking for RMDIR... " >&6; }
9772           if test ! -x "$tool_specified"; then
9773             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9774 $as_echo "not found" >&6; }
9775             as_fn_error $? "User supplied tool RMDIR=$tool_specified does not exist or is not executable" "$LINENO" 5
9776           fi
9777           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9778 $as_echo "$tool_specified" >&6; }
9779         fi
9780       fi
9781     fi
9782 
9783   fi
9784 
9785 
9786 
9787   if test "x$RMDIR" = x; then
9788     as_fn_error $? "Could not find required tool for RMDIR" "$LINENO" 5
9789   fi
9790 
9791 
9792 
9793 
9794 
9795   # Publish this variable in the help.
9796 
9797 
9798   if [ -z "${SH+x}" ]; then
9799     # The variable is not set by user, try to locate tool using the code snippet
9800     for ac_prog in sh
9801 do
9802   # Extract the first word of "$ac_prog", so it can be a program name with args.
9803 set dummy $ac_prog; ac_word=$2
9804 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9805 $as_echo_n "checking for $ac_word... " >&6; }
9806 if ${ac_cv_path_SH+:} false; then :
9807   $as_echo_n "(cached) " >&6
9808 else
9809   case $SH in
9810   [\\/]* | ?:[\\/]*)
9811   ac_cv_path_SH="$SH" # Let the user override the test with a path.
9812   ;;
9813   *)
9814   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9815 for as_dir in $PATH
9816 do
9817   IFS=$as_save_IFS
9818   test -z "$as_dir" && as_dir=.
9819     for ac_exec_ext in '' $ac_executable_extensions; do
9820   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9821     ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
9822     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9823     break 2
9824   fi
9825 done
9826   done
9827 IFS=$as_save_IFS
9828 
9829   ;;
9830 esac
9831 fi
9832 SH=$ac_cv_path_SH
9833 if test -n "$SH"; then
9834   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
9835 $as_echo "$SH" >&6; }
9836 else
9837   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9838 $as_echo "no" >&6; }
9839 fi
9840 
9841 
9842   test -n "$SH" && break
9843 done
9844 
9845   else
9846     # The variable is set, but is it from the command line or the environment?
9847 
9848     # Try to remove the string !SH! from our list.
9849     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SH!/}
9850     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9851       # If it failed, the variable was not from the command line. Ignore it,
9852       # but warn the user (except for BASH, which is always set by the calling BASH).
9853       if test "xSH" != xBASH; then
9854         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SH from the environment. Use command line variables instead." >&5
9855 $as_echo "$as_me: WARNING: Ignoring value of SH from the environment. Use command line variables instead." >&2;}
9856       fi
9857       # Try to locate tool using the code snippet
9858       for ac_prog in sh
9859 do
9860   # Extract the first word of "$ac_prog", so it can be a program name with args.
9861 set dummy $ac_prog; ac_word=$2
9862 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9863 $as_echo_n "checking for $ac_word... " >&6; }
9864 if ${ac_cv_path_SH+:} false; then :
9865   $as_echo_n "(cached) " >&6
9866 else
9867   case $SH in
9868   [\\/]* | ?:[\\/]*)
9869   ac_cv_path_SH="$SH" # Let the user override the test with a path.
9870   ;;
9871   *)
9872   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9873 for as_dir in $PATH
9874 do
9875   IFS=$as_save_IFS
9876   test -z "$as_dir" && as_dir=.
9877     for ac_exec_ext in '' $ac_executable_extensions; do
9878   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9879     ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
9880     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9881     break 2
9882   fi
9883 done
9884   done
9885 IFS=$as_save_IFS
9886 
9887   ;;
9888 esac
9889 fi
9890 SH=$ac_cv_path_SH
9891 if test -n "$SH"; then
9892   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
9893 $as_echo "$SH" >&6; }
9894 else
9895   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9896 $as_echo "no" >&6; }
9897 fi
9898 
9899 
9900   test -n "$SH" && break
9901 done
9902 
9903     else
9904       # If it succeeded, then it was overridden by the user. We will use it
9905       # for the tool.
9906 
9907       # First remove it from the list of overridden variables, so we can test
9908       # for unknown variables in the end.
9909       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9910 
9911       # Check if we try to supply an empty value
9912       if test "x$SH" = x; then
9913         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool SH= (no value)" >&5
9914 $as_echo "$as_me: Setting user supplied tool SH= (no value)" >&6;}
9915         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SH" >&5
9916 $as_echo_n "checking for SH... " >&6; }
9917         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
9918 $as_echo "disabled" >&6; }
9919       else
9920         # Check if the provided tool contains a complete path.
9921         tool_specified="$SH"
9922         tool_basename="${tool_specified##*/}"
9923         if test "x$tool_basename" = "x$tool_specified"; then
9924           # A command without a complete path is provided, search $PATH.
9925           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SH=$tool_basename" >&5
9926 $as_echo "$as_me: Will search for user supplied tool SH=$tool_basename" >&6;}
9927           # Extract the first word of "$tool_basename", so it can be a program name with args.
9928 set dummy $tool_basename; ac_word=$2
9929 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9930 $as_echo_n "checking for $ac_word... " >&6; }
9931 if ${ac_cv_path_SH+:} false; then :
9932   $as_echo_n "(cached) " >&6
9933 else
9934   case $SH in
9935   [\\/]* | ?:[\\/]*)
9936   ac_cv_path_SH="$SH" # Let the user override the test with a path.
9937   ;;
9938   *)
9939   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9940 for as_dir in $PATH
9941 do
9942   IFS=$as_save_IFS
9943   test -z "$as_dir" && as_dir=.
9944     for ac_exec_ext in '' $ac_executable_extensions; do
9945   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9946     ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
9947     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9948     break 2
9949   fi
9950 done
9951   done
9952 IFS=$as_save_IFS
9953 
9954   ;;
9955 esac
9956 fi
9957 SH=$ac_cv_path_SH
9958 if test -n "$SH"; then
9959   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
9960 $as_echo "$SH" >&6; }
9961 else
9962   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9963 $as_echo "no" >&6; }
9964 fi
9965 
9966 
9967           if test "x$SH" = x; then
9968             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9969           fi
9970         else
9971           # Otherwise we believe it is a complete path. Use it as it is.
9972           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SH=$tool_specified" >&5
9973 $as_echo "$as_me: Will use user supplied tool SH=$tool_specified" >&6;}
9974           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SH" >&5
9975 $as_echo_n "checking for SH... " >&6; }
9976           if test ! -x "$tool_specified"; then
9977             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9978 $as_echo "not found" >&6; }
9979             as_fn_error $? "User supplied tool SH=$tool_specified does not exist or is not executable" "$LINENO" 5
9980           fi
9981           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9982 $as_echo "$tool_specified" >&6; }
9983         fi
9984       fi
9985     fi
9986 
9987   fi
9988 
9989 
9990 
9991   if test "x$SH" = x; then
9992     as_fn_error $? "Could not find required tool for SH" "$LINENO" 5
9993   fi
9994 
9995 
9996 
9997 
9998 
9999   # Publish this variable in the help.
10000 
10001 
10002   if [ -z "${SORT+x}" ]; then
10003     # The variable is not set by user, try to locate tool using the code snippet
10004     for ac_prog in sort
10005 do
10006   # Extract the first word of "$ac_prog", so it can be a program name with args.
10007 set dummy $ac_prog; ac_word=$2
10008 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10009 $as_echo_n "checking for $ac_word... " >&6; }
10010 if ${ac_cv_path_SORT+:} false; then :
10011   $as_echo_n "(cached) " >&6
10012 else
10013   case $SORT in
10014   [\\/]* | ?:[\\/]*)
10015   ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
10016   ;;
10017   *)
10018   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10019 for as_dir in $PATH
10020 do
10021   IFS=$as_save_IFS
10022   test -z "$as_dir" && as_dir=.
10023     for ac_exec_ext in '' $ac_executable_extensions; do
10024   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10025     ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
10026     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10027     break 2
10028   fi
10029 done
10030   done
10031 IFS=$as_save_IFS
10032 
10033   ;;
10034 esac
10035 fi
10036 SORT=$ac_cv_path_SORT
10037 if test -n "$SORT"; then
10038   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
10039 $as_echo "$SORT" >&6; }
10040 else
10041   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10042 $as_echo "no" >&6; }
10043 fi
10044 
10045 
10046   test -n "$SORT" && break
10047 done
10048 
10049   else
10050     # The variable is set, but is it from the command line or the environment?
10051 
10052     # Try to remove the string !SORT! from our list.
10053     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SORT!/}
10054     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10055       # If it failed, the variable was not from the command line. Ignore it,
10056       # but warn the user (except for BASH, which is always set by the calling BASH).
10057       if test "xSORT" != xBASH; then
10058         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SORT from the environment. Use command line variables instead." >&5
10059 $as_echo "$as_me: WARNING: Ignoring value of SORT from the environment. Use command line variables instead." >&2;}
10060       fi
10061       # Try to locate tool using the code snippet
10062       for ac_prog in sort
10063 do
10064   # Extract the first word of "$ac_prog", so it can be a program name with args.
10065 set dummy $ac_prog; ac_word=$2
10066 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10067 $as_echo_n "checking for $ac_word... " >&6; }
10068 if ${ac_cv_path_SORT+:} false; then :
10069   $as_echo_n "(cached) " >&6
10070 else
10071   case $SORT in
10072   [\\/]* | ?:[\\/]*)
10073   ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
10074   ;;
10075   *)
10076   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10077 for as_dir in $PATH
10078 do
10079   IFS=$as_save_IFS
10080   test -z "$as_dir" && as_dir=.
10081     for ac_exec_ext in '' $ac_executable_extensions; do
10082   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10083     ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
10084     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10085     break 2
10086   fi
10087 done
10088   done
10089 IFS=$as_save_IFS
10090 
10091   ;;
10092 esac
10093 fi
10094 SORT=$ac_cv_path_SORT
10095 if test -n "$SORT"; then
10096   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
10097 $as_echo "$SORT" >&6; }
10098 else
10099   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10100 $as_echo "no" >&6; }
10101 fi
10102 
10103 
10104   test -n "$SORT" && break
10105 done
10106 
10107     else
10108       # If it succeeded, then it was overridden by the user. We will use it
10109       # for the tool.
10110 
10111       # First remove it from the list of overridden variables, so we can test
10112       # for unknown variables in the end.
10113       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10114 
10115       # Check if we try to supply an empty value
10116       if test "x$SORT" = x; then
10117         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool SORT= (no value)" >&5
10118 $as_echo "$as_me: Setting user supplied tool SORT= (no value)" >&6;}
10119         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SORT" >&5
10120 $as_echo_n "checking for SORT... " >&6; }
10121         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
10122 $as_echo "disabled" >&6; }
10123       else
10124         # Check if the provided tool contains a complete path.
10125         tool_specified="$SORT"
10126         tool_basename="${tool_specified##*/}"
10127         if test "x$tool_basename" = "x$tool_specified"; then
10128           # A command without a complete path is provided, search $PATH.
10129           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SORT=$tool_basename" >&5
10130 $as_echo "$as_me: Will search for user supplied tool SORT=$tool_basename" >&6;}
10131           # Extract the first word of "$tool_basename", so it can be a program name with args.
10132 set dummy $tool_basename; ac_word=$2
10133 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10134 $as_echo_n "checking for $ac_word... " >&6; }
10135 if ${ac_cv_path_SORT+:} false; then :
10136   $as_echo_n "(cached) " >&6
10137 else
10138   case $SORT in
10139   [\\/]* | ?:[\\/]*)
10140   ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
10141   ;;
10142   *)
10143   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10144 for as_dir in $PATH
10145 do
10146   IFS=$as_save_IFS
10147   test -z "$as_dir" && as_dir=.
10148     for ac_exec_ext in '' $ac_executable_extensions; do
10149   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10150     ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
10151     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10152     break 2
10153   fi
10154 done
10155   done
10156 IFS=$as_save_IFS
10157 
10158   ;;
10159 esac
10160 fi
10161 SORT=$ac_cv_path_SORT
10162 if test -n "$SORT"; then
10163   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
10164 $as_echo "$SORT" >&6; }
10165 else
10166   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10167 $as_echo "no" >&6; }
10168 fi
10169 
10170 
10171           if test "x$SORT" = x; then
10172             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10173           fi
10174         else
10175           # Otherwise we believe it is a complete path. Use it as it is.
10176           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SORT=$tool_specified" >&5
10177 $as_echo "$as_me: Will use user supplied tool SORT=$tool_specified" >&6;}
10178           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SORT" >&5
10179 $as_echo_n "checking for SORT... " >&6; }
10180           if test ! -x "$tool_specified"; then
10181             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10182 $as_echo "not found" >&6; }
10183             as_fn_error $? "User supplied tool SORT=$tool_specified does not exist or is not executable" "$LINENO" 5
10184           fi
10185           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10186 $as_echo "$tool_specified" >&6; }
10187         fi
10188       fi
10189     fi
10190 
10191   fi
10192 
10193 
10194 
10195   if test "x$SORT" = x; then
10196     as_fn_error $? "Could not find required tool for SORT" "$LINENO" 5
10197   fi
10198 
10199 
10200 
10201 
10202 
10203   # Publish this variable in the help.
10204 
10205 
10206   if [ -z "${TAIL+x}" ]; then
10207     # The variable is not set by user, try to locate tool using the code snippet
10208     for ac_prog in tail
10209 do
10210   # Extract the first word of "$ac_prog", so it can be a program name with args.
10211 set dummy $ac_prog; ac_word=$2
10212 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10213 $as_echo_n "checking for $ac_word... " >&6; }
10214 if ${ac_cv_path_TAIL+:} false; then :
10215   $as_echo_n "(cached) " >&6
10216 else
10217   case $TAIL in
10218   [\\/]* | ?:[\\/]*)
10219   ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
10220   ;;
10221   *)
10222   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10223 for as_dir in $PATH
10224 do
10225   IFS=$as_save_IFS
10226   test -z "$as_dir" && as_dir=.
10227     for ac_exec_ext in '' $ac_executable_extensions; do
10228   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10229     ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
10230     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10231     break 2
10232   fi
10233 done
10234   done
10235 IFS=$as_save_IFS
10236 
10237   ;;
10238 esac
10239 fi
10240 TAIL=$ac_cv_path_TAIL
10241 if test -n "$TAIL"; then
10242   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
10243 $as_echo "$TAIL" >&6; }
10244 else
10245   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10246 $as_echo "no" >&6; }
10247 fi
10248 
10249 
10250   test -n "$TAIL" && break
10251 done
10252 
10253   else
10254     # The variable is set, but is it from the command line or the environment?
10255 
10256     # Try to remove the string !TAIL! from our list.
10257     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TAIL!/}
10258     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10259       # If it failed, the variable was not from the command line. Ignore it,
10260       # but warn the user (except for BASH, which is always set by the calling BASH).
10261       if test "xTAIL" != xBASH; then
10262         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TAIL from the environment. Use command line variables instead." >&5
10263 $as_echo "$as_me: WARNING: Ignoring value of TAIL from the environment. Use command line variables instead." >&2;}
10264       fi
10265       # Try to locate tool using the code snippet
10266       for ac_prog in tail
10267 do
10268   # Extract the first word of "$ac_prog", so it can be a program name with args.
10269 set dummy $ac_prog; ac_word=$2
10270 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10271 $as_echo_n "checking for $ac_word... " >&6; }
10272 if ${ac_cv_path_TAIL+:} false; then :
10273   $as_echo_n "(cached) " >&6
10274 else
10275   case $TAIL in
10276   [\\/]* | ?:[\\/]*)
10277   ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
10278   ;;
10279   *)
10280   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10281 for as_dir in $PATH
10282 do
10283   IFS=$as_save_IFS
10284   test -z "$as_dir" && as_dir=.
10285     for ac_exec_ext in '' $ac_executable_extensions; do
10286   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10287     ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
10288     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10289     break 2
10290   fi
10291 done
10292   done
10293 IFS=$as_save_IFS
10294 
10295   ;;
10296 esac
10297 fi
10298 TAIL=$ac_cv_path_TAIL
10299 if test -n "$TAIL"; then
10300   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
10301 $as_echo "$TAIL" >&6; }
10302 else
10303   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10304 $as_echo "no" >&6; }
10305 fi
10306 
10307 
10308   test -n "$TAIL" && break
10309 done
10310 
10311     else
10312       # If it succeeded, then it was overridden by the user. We will use it
10313       # for the tool.
10314 
10315       # First remove it from the list of overridden variables, so we can test
10316       # for unknown variables in the end.
10317       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10318 
10319       # Check if we try to supply an empty value
10320       if test "x$TAIL" = x; then
10321         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool TAIL= (no value)" >&5
10322 $as_echo "$as_me: Setting user supplied tool TAIL= (no value)" >&6;}
10323         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAIL" >&5
10324 $as_echo_n "checking for TAIL... " >&6; }
10325         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
10326 $as_echo "disabled" >&6; }
10327       else
10328         # Check if the provided tool contains a complete path.
10329         tool_specified="$TAIL"
10330         tool_basename="${tool_specified##*/}"
10331         if test "x$tool_basename" = "x$tool_specified"; then
10332           # A command without a complete path is provided, search $PATH.
10333           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TAIL=$tool_basename" >&5
10334 $as_echo "$as_me: Will search for user supplied tool TAIL=$tool_basename" >&6;}
10335           # Extract the first word of "$tool_basename", so it can be a program name with args.
10336 set dummy $tool_basename; ac_word=$2
10337 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10338 $as_echo_n "checking for $ac_word... " >&6; }
10339 if ${ac_cv_path_TAIL+:} false; then :
10340   $as_echo_n "(cached) " >&6
10341 else
10342   case $TAIL in
10343   [\\/]* | ?:[\\/]*)
10344   ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
10345   ;;
10346   *)
10347   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10348 for as_dir in $PATH
10349 do
10350   IFS=$as_save_IFS
10351   test -z "$as_dir" && as_dir=.
10352     for ac_exec_ext in '' $ac_executable_extensions; do
10353   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10354     ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
10355     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10356     break 2
10357   fi
10358 done
10359   done
10360 IFS=$as_save_IFS
10361 
10362   ;;
10363 esac
10364 fi
10365 TAIL=$ac_cv_path_TAIL
10366 if test -n "$TAIL"; then
10367   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
10368 $as_echo "$TAIL" >&6; }
10369 else
10370   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10371 $as_echo "no" >&6; }
10372 fi
10373 
10374 
10375           if test "x$TAIL" = x; then
10376             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10377           fi
10378         else
10379           # Otherwise we believe it is a complete path. Use it as it is.
10380           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TAIL=$tool_specified" >&5
10381 $as_echo "$as_me: Will use user supplied tool TAIL=$tool_specified" >&6;}
10382           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAIL" >&5
10383 $as_echo_n "checking for TAIL... " >&6; }
10384           if test ! -x "$tool_specified"; then
10385             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10386 $as_echo "not found" >&6; }
10387             as_fn_error $? "User supplied tool TAIL=$tool_specified does not exist or is not executable" "$LINENO" 5
10388           fi
10389           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10390 $as_echo "$tool_specified" >&6; }
10391         fi
10392       fi
10393     fi
10394 
10395   fi
10396 
10397 
10398 
10399   if test "x$TAIL" = x; then
10400     as_fn_error $? "Could not find required tool for TAIL" "$LINENO" 5
10401   fi
10402 
10403 
10404 
10405 
10406 
10407   # Publish this variable in the help.
10408 
10409 
10410   if [ -z "${TAR+x}" ]; then
10411     # The variable is not set by user, try to locate tool using the code snippet
10412     for ac_prog in tar
10413 do
10414   # Extract the first word of "$ac_prog", so it can be a program name with args.
10415 set dummy $ac_prog; ac_word=$2
10416 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10417 $as_echo_n "checking for $ac_word... " >&6; }
10418 if ${ac_cv_path_TAR+:} false; then :
10419   $as_echo_n "(cached) " >&6
10420 else
10421   case $TAR in
10422   [\\/]* | ?:[\\/]*)
10423   ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
10424   ;;
10425   *)
10426   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10427 for as_dir in $PATH
10428 do
10429   IFS=$as_save_IFS
10430   test -z "$as_dir" && as_dir=.
10431     for ac_exec_ext in '' $ac_executable_extensions; do
10432   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10433     ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
10434     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10435     break 2
10436   fi
10437 done
10438   done
10439 IFS=$as_save_IFS
10440 
10441   ;;
10442 esac
10443 fi
10444 TAR=$ac_cv_path_TAR
10445 if test -n "$TAR"; then
10446   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
10447 $as_echo "$TAR" >&6; }
10448 else
10449   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10450 $as_echo "no" >&6; }
10451 fi
10452 
10453 
10454   test -n "$TAR" && break
10455 done
10456 
10457   else
10458     # The variable is set, but is it from the command line or the environment?
10459 
10460     # Try to remove the string !TAR! from our list.
10461     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TAR!/}
10462     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10463       # If it failed, the variable was not from the command line. Ignore it,
10464       # but warn the user (except for BASH, which is always set by the calling BASH).
10465       if test "xTAR" != xBASH; then
10466         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TAR from the environment. Use command line variables instead." >&5
10467 $as_echo "$as_me: WARNING: Ignoring value of TAR from the environment. Use command line variables instead." >&2;}
10468       fi
10469       # Try to locate tool using the code snippet
10470       for ac_prog in tar
10471 do
10472   # Extract the first word of "$ac_prog", so it can be a program name with args.
10473 set dummy $ac_prog; ac_word=$2
10474 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10475 $as_echo_n "checking for $ac_word... " >&6; }
10476 if ${ac_cv_path_TAR+:} false; then :
10477   $as_echo_n "(cached) " >&6
10478 else
10479   case $TAR in
10480   [\\/]* | ?:[\\/]*)
10481   ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
10482   ;;
10483   *)
10484   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10485 for as_dir in $PATH
10486 do
10487   IFS=$as_save_IFS
10488   test -z "$as_dir" && as_dir=.
10489     for ac_exec_ext in '' $ac_executable_extensions; do
10490   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10491     ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
10492     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10493     break 2
10494   fi
10495 done
10496   done
10497 IFS=$as_save_IFS
10498 
10499   ;;
10500 esac
10501 fi
10502 TAR=$ac_cv_path_TAR
10503 if test -n "$TAR"; then
10504   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
10505 $as_echo "$TAR" >&6; }
10506 else
10507   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10508 $as_echo "no" >&6; }
10509 fi
10510 
10511 
10512   test -n "$TAR" && break
10513 done
10514 
10515     else
10516       # If it succeeded, then it was overridden by the user. We will use it
10517       # for the tool.
10518 
10519       # First remove it from the list of overridden variables, so we can test
10520       # for unknown variables in the end.
10521       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10522 
10523       # Check if we try to supply an empty value
10524       if test "x$TAR" = x; then
10525         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool TAR= (no value)" >&5
10526 $as_echo "$as_me: Setting user supplied tool TAR= (no value)" >&6;}
10527         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAR" >&5
10528 $as_echo_n "checking for TAR... " >&6; }
10529         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
10530 $as_echo "disabled" >&6; }
10531       else
10532         # Check if the provided tool contains a complete path.
10533         tool_specified="$TAR"
10534         tool_basename="${tool_specified##*/}"
10535         if test "x$tool_basename" = "x$tool_specified"; then
10536           # A command without a complete path is provided, search $PATH.
10537           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TAR=$tool_basename" >&5
10538 $as_echo "$as_me: Will search for user supplied tool TAR=$tool_basename" >&6;}
10539           # Extract the first word of "$tool_basename", so it can be a program name with args.
10540 set dummy $tool_basename; ac_word=$2
10541 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10542 $as_echo_n "checking for $ac_word... " >&6; }
10543 if ${ac_cv_path_TAR+:} false; then :
10544   $as_echo_n "(cached) " >&6
10545 else
10546   case $TAR in
10547   [\\/]* | ?:[\\/]*)
10548   ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
10549   ;;
10550   *)
10551   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10552 for as_dir in $PATH
10553 do
10554   IFS=$as_save_IFS
10555   test -z "$as_dir" && as_dir=.
10556     for ac_exec_ext in '' $ac_executable_extensions; do
10557   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10558     ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
10559     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10560     break 2
10561   fi
10562 done
10563   done
10564 IFS=$as_save_IFS
10565 
10566   ;;
10567 esac
10568 fi
10569 TAR=$ac_cv_path_TAR
10570 if test -n "$TAR"; then
10571   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
10572 $as_echo "$TAR" >&6; }
10573 else
10574   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10575 $as_echo "no" >&6; }
10576 fi
10577 
10578 
10579           if test "x$TAR" = x; then
10580             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10581           fi
10582         else
10583           # Otherwise we believe it is a complete path. Use it as it is.
10584           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TAR=$tool_specified" >&5
10585 $as_echo "$as_me: Will use user supplied tool TAR=$tool_specified" >&6;}
10586           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAR" >&5
10587 $as_echo_n "checking for TAR... " >&6; }
10588           if test ! -x "$tool_specified"; then
10589             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10590 $as_echo "not found" >&6; }
10591             as_fn_error $? "User supplied tool TAR=$tool_specified does not exist or is not executable" "$LINENO" 5
10592           fi
10593           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10594 $as_echo "$tool_specified" >&6; }
10595         fi
10596       fi
10597     fi
10598 
10599   fi
10600 
10601 
10602 
10603   if test "x$TAR" = x; then
10604     as_fn_error $? "Could not find required tool for TAR" "$LINENO" 5
10605   fi
10606 
10607 
10608 
10609 
10610 
10611   # Publish this variable in the help.
10612 
10613 
10614   if [ -z "${TEE+x}" ]; then
10615     # The variable is not set by user, try to locate tool using the code snippet
10616     for ac_prog in tee
10617 do
10618   # Extract the first word of "$ac_prog", so it can be a program name with args.
10619 set dummy $ac_prog; ac_word=$2
10620 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10621 $as_echo_n "checking for $ac_word... " >&6; }
10622 if ${ac_cv_path_TEE+:} false; then :
10623   $as_echo_n "(cached) " >&6
10624 else
10625   case $TEE in
10626   [\\/]* | ?:[\\/]*)
10627   ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
10628   ;;
10629   *)
10630   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10631 for as_dir in $PATH
10632 do
10633   IFS=$as_save_IFS
10634   test -z "$as_dir" && as_dir=.
10635     for ac_exec_ext in '' $ac_executable_extensions; do
10636   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10637     ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
10638     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10639     break 2
10640   fi
10641 done
10642   done
10643 IFS=$as_save_IFS
10644 
10645   ;;
10646 esac
10647 fi
10648 TEE=$ac_cv_path_TEE
10649 if test -n "$TEE"; then
10650   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
10651 $as_echo "$TEE" >&6; }
10652 else
10653   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10654 $as_echo "no" >&6; }
10655 fi
10656 
10657 
10658   test -n "$TEE" && break
10659 done
10660 
10661   else
10662     # The variable is set, but is it from the command line or the environment?
10663 
10664     # Try to remove the string !TEE! from our list.
10665     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TEE!/}
10666     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10667       # If it failed, the variable was not from the command line. Ignore it,
10668       # but warn the user (except for BASH, which is always set by the calling BASH).
10669       if test "xTEE" != xBASH; then
10670         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TEE from the environment. Use command line variables instead." >&5
10671 $as_echo "$as_me: WARNING: Ignoring value of TEE from the environment. Use command line variables instead." >&2;}
10672       fi
10673       # Try to locate tool using the code snippet
10674       for ac_prog in tee
10675 do
10676   # Extract the first word of "$ac_prog", so it can be a program name with args.
10677 set dummy $ac_prog; ac_word=$2
10678 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10679 $as_echo_n "checking for $ac_word... " >&6; }
10680 if ${ac_cv_path_TEE+:} false; then :
10681   $as_echo_n "(cached) " >&6
10682 else
10683   case $TEE in
10684   [\\/]* | ?:[\\/]*)
10685   ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
10686   ;;
10687   *)
10688   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10689 for as_dir in $PATH
10690 do
10691   IFS=$as_save_IFS
10692   test -z "$as_dir" && as_dir=.
10693     for ac_exec_ext in '' $ac_executable_extensions; do
10694   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10695     ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
10696     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10697     break 2
10698   fi
10699 done
10700   done
10701 IFS=$as_save_IFS
10702 
10703   ;;
10704 esac
10705 fi
10706 TEE=$ac_cv_path_TEE
10707 if test -n "$TEE"; then
10708   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
10709 $as_echo "$TEE" >&6; }
10710 else
10711   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10712 $as_echo "no" >&6; }
10713 fi
10714 
10715 
10716   test -n "$TEE" && break
10717 done
10718 
10719     else
10720       # If it succeeded, then it was overridden by the user. We will use it
10721       # for the tool.
10722 
10723       # First remove it from the list of overridden variables, so we can test
10724       # for unknown variables in the end.
10725       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10726 
10727       # Check if we try to supply an empty value
10728       if test "x$TEE" = x; then
10729         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool TEE= (no value)" >&5
10730 $as_echo "$as_me: Setting user supplied tool TEE= (no value)" >&6;}
10731         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TEE" >&5
10732 $as_echo_n "checking for TEE... " >&6; }
10733         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
10734 $as_echo "disabled" >&6; }
10735       else
10736         # Check if the provided tool contains a complete path.
10737         tool_specified="$TEE"
10738         tool_basename="${tool_specified##*/}"
10739         if test "x$tool_basename" = "x$tool_specified"; then
10740           # A command without a complete path is provided, search $PATH.
10741           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TEE=$tool_basename" >&5
10742 $as_echo "$as_me: Will search for user supplied tool TEE=$tool_basename" >&6;}
10743           # Extract the first word of "$tool_basename", so it can be a program name with args.
10744 set dummy $tool_basename; ac_word=$2
10745 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10746 $as_echo_n "checking for $ac_word... " >&6; }
10747 if ${ac_cv_path_TEE+:} false; then :
10748   $as_echo_n "(cached) " >&6
10749 else
10750   case $TEE in
10751   [\\/]* | ?:[\\/]*)
10752   ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
10753   ;;
10754   *)
10755   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10756 for as_dir in $PATH
10757 do
10758   IFS=$as_save_IFS
10759   test -z "$as_dir" && as_dir=.
10760     for ac_exec_ext in '' $ac_executable_extensions; do
10761   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10762     ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
10763     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10764     break 2
10765   fi
10766 done
10767   done
10768 IFS=$as_save_IFS
10769 
10770   ;;
10771 esac
10772 fi
10773 TEE=$ac_cv_path_TEE
10774 if test -n "$TEE"; then
10775   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
10776 $as_echo "$TEE" >&6; }
10777 else
10778   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10779 $as_echo "no" >&6; }
10780 fi
10781 
10782 
10783           if test "x$TEE" = x; then
10784             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10785           fi
10786         else
10787           # Otherwise we believe it is a complete path. Use it as it is.
10788           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TEE=$tool_specified" >&5
10789 $as_echo "$as_me: Will use user supplied tool TEE=$tool_specified" >&6;}
10790           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TEE" >&5
10791 $as_echo_n "checking for TEE... " >&6; }
10792           if test ! -x "$tool_specified"; then
10793             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10794 $as_echo "not found" >&6; }
10795             as_fn_error $? "User supplied tool TEE=$tool_specified does not exist or is not executable" "$LINENO" 5
10796           fi
10797           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10798 $as_echo "$tool_specified" >&6; }
10799         fi
10800       fi
10801     fi
10802 
10803   fi
10804 
10805 
10806 
10807   if test "x$TEE" = x; then
10808     as_fn_error $? "Could not find required tool for TEE" "$LINENO" 5
10809   fi
10810 
10811 
10812 
10813 
10814 
10815   # Publish this variable in the help.
10816 
10817 
10818   if [ -z "${TOUCH+x}" ]; then
10819     # The variable is not set by user, try to locate tool using the code snippet
10820     for ac_prog in touch
10821 do
10822   # Extract the first word of "$ac_prog", so it can be a program name with args.
10823 set dummy $ac_prog; ac_word=$2
10824 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10825 $as_echo_n "checking for $ac_word... " >&6; }
10826 if ${ac_cv_path_TOUCH+:} false; then :
10827   $as_echo_n "(cached) " >&6
10828 else
10829   case $TOUCH in
10830   [\\/]* | ?:[\\/]*)
10831   ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
10832   ;;
10833   *)
10834   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10835 for as_dir in $PATH
10836 do
10837   IFS=$as_save_IFS
10838   test -z "$as_dir" && as_dir=.
10839     for ac_exec_ext in '' $ac_executable_extensions; do
10840   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10841     ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
10842     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10843     break 2
10844   fi
10845 done
10846   done
10847 IFS=$as_save_IFS
10848 
10849   ;;
10850 esac
10851 fi
10852 TOUCH=$ac_cv_path_TOUCH
10853 if test -n "$TOUCH"; then
10854   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
10855 $as_echo "$TOUCH" >&6; }
10856 else
10857   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10858 $as_echo "no" >&6; }
10859 fi
10860 
10861 
10862   test -n "$TOUCH" && break
10863 done
10864 
10865   else
10866     # The variable is set, but is it from the command line or the environment?
10867 
10868     # Try to remove the string !TOUCH! from our list.
10869     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TOUCH!/}
10870     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10871       # If it failed, the variable was not from the command line. Ignore it,
10872       # but warn the user (except for BASH, which is always set by the calling BASH).
10873       if test "xTOUCH" != xBASH; then
10874         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TOUCH from the environment. Use command line variables instead." >&5
10875 $as_echo "$as_me: WARNING: Ignoring value of TOUCH from the environment. Use command line variables instead." >&2;}
10876       fi
10877       # Try to locate tool using the code snippet
10878       for ac_prog in touch
10879 do
10880   # Extract the first word of "$ac_prog", so it can be a program name with args.
10881 set dummy $ac_prog; ac_word=$2
10882 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10883 $as_echo_n "checking for $ac_word... " >&6; }
10884 if ${ac_cv_path_TOUCH+:} false; then :
10885   $as_echo_n "(cached) " >&6
10886 else
10887   case $TOUCH in
10888   [\\/]* | ?:[\\/]*)
10889   ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
10890   ;;
10891   *)
10892   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10893 for as_dir in $PATH
10894 do
10895   IFS=$as_save_IFS
10896   test -z "$as_dir" && as_dir=.
10897     for ac_exec_ext in '' $ac_executable_extensions; do
10898   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10899     ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
10900     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10901     break 2
10902   fi
10903 done
10904   done
10905 IFS=$as_save_IFS
10906 
10907   ;;
10908 esac
10909 fi
10910 TOUCH=$ac_cv_path_TOUCH
10911 if test -n "$TOUCH"; then
10912   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
10913 $as_echo "$TOUCH" >&6; }
10914 else
10915   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10916 $as_echo "no" >&6; }
10917 fi
10918 
10919 
10920   test -n "$TOUCH" && break
10921 done
10922 
10923     else
10924       # If it succeeded, then it was overridden by the user. We will use it
10925       # for the tool.
10926 
10927       # First remove it from the list of overridden variables, so we can test
10928       # for unknown variables in the end.
10929       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10930 
10931       # Check if we try to supply an empty value
10932       if test "x$TOUCH" = x; then
10933         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool TOUCH= (no value)" >&5
10934 $as_echo "$as_me: Setting user supplied tool TOUCH= (no value)" >&6;}
10935         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TOUCH" >&5
10936 $as_echo_n "checking for TOUCH... " >&6; }
10937         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
10938 $as_echo "disabled" >&6; }
10939       else
10940         # Check if the provided tool contains a complete path.
10941         tool_specified="$TOUCH"
10942         tool_basename="${tool_specified##*/}"
10943         if test "x$tool_basename" = "x$tool_specified"; then
10944           # A command without a complete path is provided, search $PATH.
10945           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TOUCH=$tool_basename" >&5
10946 $as_echo "$as_me: Will search for user supplied tool TOUCH=$tool_basename" >&6;}
10947           # Extract the first word of "$tool_basename", so it can be a program name with args.
10948 set dummy $tool_basename; ac_word=$2
10949 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10950 $as_echo_n "checking for $ac_word... " >&6; }
10951 if ${ac_cv_path_TOUCH+:} false; then :
10952   $as_echo_n "(cached) " >&6
10953 else
10954   case $TOUCH in
10955   [\\/]* | ?:[\\/]*)
10956   ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
10957   ;;
10958   *)
10959   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10960 for as_dir in $PATH
10961 do
10962   IFS=$as_save_IFS
10963   test -z "$as_dir" && as_dir=.
10964     for ac_exec_ext in '' $ac_executable_extensions; do
10965   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10966     ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
10967     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10968     break 2
10969   fi
10970 done
10971   done
10972 IFS=$as_save_IFS
10973 
10974   ;;
10975 esac
10976 fi
10977 TOUCH=$ac_cv_path_TOUCH
10978 if test -n "$TOUCH"; then
10979   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
10980 $as_echo "$TOUCH" >&6; }
10981 else
10982   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10983 $as_echo "no" >&6; }
10984 fi
10985 
10986 
10987           if test "x$TOUCH" = x; then
10988             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10989           fi
10990         else
10991           # Otherwise we believe it is a complete path. Use it as it is.
10992           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TOUCH=$tool_specified" >&5
10993 $as_echo "$as_me: Will use user supplied tool TOUCH=$tool_specified" >&6;}
10994           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TOUCH" >&5
10995 $as_echo_n "checking for TOUCH... " >&6; }
10996           if test ! -x "$tool_specified"; then
10997             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10998 $as_echo "not found" >&6; }
10999             as_fn_error $? "User supplied tool TOUCH=$tool_specified does not exist or is not executable" "$LINENO" 5
11000           fi
11001           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11002 $as_echo "$tool_specified" >&6; }
11003         fi
11004       fi
11005     fi
11006 
11007   fi
11008 
11009 
11010 
11011   if test "x$TOUCH" = x; then
11012     as_fn_error $? "Could not find required tool for TOUCH" "$LINENO" 5
11013   fi
11014 
11015 
11016 
11017 
11018 
11019   # Publish this variable in the help.
11020 
11021 
11022   if [ -z "${TR+x}" ]; then
11023     # The variable is not set by user, try to locate tool using the code snippet
11024     for ac_prog in tr
11025 do
11026   # Extract the first word of "$ac_prog", so it can be a program name with args.
11027 set dummy $ac_prog; ac_word=$2
11028 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11029 $as_echo_n "checking for $ac_word... " >&6; }
11030 if ${ac_cv_path_TR+:} false; then :
11031   $as_echo_n "(cached) " >&6
11032 else
11033   case $TR in
11034   [\\/]* | ?:[\\/]*)
11035   ac_cv_path_TR="$TR" # Let the user override the test with a path.
11036   ;;
11037   *)
11038   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11039 for as_dir in $PATH
11040 do
11041   IFS=$as_save_IFS
11042   test -z "$as_dir" && as_dir=.
11043     for ac_exec_ext in '' $ac_executable_extensions; do
11044   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11045     ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
11046     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11047     break 2
11048   fi
11049 done
11050   done
11051 IFS=$as_save_IFS
11052 
11053   ;;
11054 esac
11055 fi
11056 TR=$ac_cv_path_TR
11057 if test -n "$TR"; then
11058   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
11059 $as_echo "$TR" >&6; }
11060 else
11061   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11062 $as_echo "no" >&6; }
11063 fi
11064 
11065 
11066   test -n "$TR" && break
11067 done
11068 
11069   else
11070     # The variable is set, but is it from the command line or the environment?
11071 
11072     # Try to remove the string !TR! from our list.
11073     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TR!/}
11074     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11075       # If it failed, the variable was not from the command line. Ignore it,
11076       # but warn the user (except for BASH, which is always set by the calling BASH).
11077       if test "xTR" != xBASH; then
11078         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TR from the environment. Use command line variables instead." >&5
11079 $as_echo "$as_me: WARNING: Ignoring value of TR from the environment. Use command line variables instead." >&2;}
11080       fi
11081       # Try to locate tool using the code snippet
11082       for ac_prog in tr
11083 do
11084   # Extract the first word of "$ac_prog", so it can be a program name with args.
11085 set dummy $ac_prog; ac_word=$2
11086 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11087 $as_echo_n "checking for $ac_word... " >&6; }
11088 if ${ac_cv_path_TR+:} false; then :
11089   $as_echo_n "(cached) " >&6
11090 else
11091   case $TR in
11092   [\\/]* | ?:[\\/]*)
11093   ac_cv_path_TR="$TR" # Let the user override the test with a path.
11094   ;;
11095   *)
11096   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11097 for as_dir in $PATH
11098 do
11099   IFS=$as_save_IFS
11100   test -z "$as_dir" && as_dir=.
11101     for ac_exec_ext in '' $ac_executable_extensions; do
11102   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11103     ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
11104     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11105     break 2
11106   fi
11107 done
11108   done
11109 IFS=$as_save_IFS
11110 
11111   ;;
11112 esac
11113 fi
11114 TR=$ac_cv_path_TR
11115 if test -n "$TR"; then
11116   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
11117 $as_echo "$TR" >&6; }
11118 else
11119   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11120 $as_echo "no" >&6; }
11121 fi
11122 
11123 
11124   test -n "$TR" && break
11125 done
11126 
11127     else
11128       # If it succeeded, then it was overridden by the user. We will use it
11129       # for the tool.
11130 
11131       # First remove it from the list of overridden variables, so we can test
11132       # for unknown variables in the end.
11133       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11134 
11135       # Check if we try to supply an empty value
11136       if test "x$TR" = x; then
11137         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool TR= (no value)" >&5
11138 $as_echo "$as_me: Setting user supplied tool TR= (no value)" >&6;}
11139         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TR" >&5
11140 $as_echo_n "checking for TR... " >&6; }
11141         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
11142 $as_echo "disabled" >&6; }
11143       else
11144         # Check if the provided tool contains a complete path.
11145         tool_specified="$TR"
11146         tool_basename="${tool_specified##*/}"
11147         if test "x$tool_basename" = "x$tool_specified"; then
11148           # A command without a complete path is provided, search $PATH.
11149           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TR=$tool_basename" >&5
11150 $as_echo "$as_me: Will search for user supplied tool TR=$tool_basename" >&6;}
11151           # Extract the first word of "$tool_basename", so it can be a program name with args.
11152 set dummy $tool_basename; ac_word=$2
11153 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11154 $as_echo_n "checking for $ac_word... " >&6; }
11155 if ${ac_cv_path_TR+:} false; then :
11156   $as_echo_n "(cached) " >&6
11157 else
11158   case $TR in
11159   [\\/]* | ?:[\\/]*)
11160   ac_cv_path_TR="$TR" # Let the user override the test with a path.
11161   ;;
11162   *)
11163   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11164 for as_dir in $PATH
11165 do
11166   IFS=$as_save_IFS
11167   test -z "$as_dir" && as_dir=.
11168     for ac_exec_ext in '' $ac_executable_extensions; do
11169   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11170     ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
11171     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11172     break 2
11173   fi
11174 done
11175   done
11176 IFS=$as_save_IFS
11177 
11178   ;;
11179 esac
11180 fi
11181 TR=$ac_cv_path_TR
11182 if test -n "$TR"; then
11183   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
11184 $as_echo "$TR" >&6; }
11185 else
11186   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11187 $as_echo "no" >&6; }
11188 fi
11189 
11190 
11191           if test "x$TR" = x; then
11192             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11193           fi
11194         else
11195           # Otherwise we believe it is a complete path. Use it as it is.
11196           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TR=$tool_specified" >&5
11197 $as_echo "$as_me: Will use user supplied tool TR=$tool_specified" >&6;}
11198           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TR" >&5
11199 $as_echo_n "checking for TR... " >&6; }
11200           if test ! -x "$tool_specified"; then
11201             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11202 $as_echo "not found" >&6; }
11203             as_fn_error $? "User supplied tool TR=$tool_specified does not exist or is not executable" "$LINENO" 5
11204           fi
11205           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11206 $as_echo "$tool_specified" >&6; }
11207         fi
11208       fi
11209     fi
11210 
11211   fi
11212 
11213 
11214 
11215   if test "x$TR" = x; then
11216     as_fn_error $? "Could not find required tool for TR" "$LINENO" 5
11217   fi
11218 
11219 
11220 
11221 
11222 
11223   # Publish this variable in the help.
11224 
11225 
11226   if [ -z "${UNAME+x}" ]; then
11227     # The variable is not set by user, try to locate tool using the code snippet
11228     for ac_prog in uname
11229 do
11230   # Extract the first word of "$ac_prog", so it can be a program name with args.
11231 set dummy $ac_prog; ac_word=$2
11232 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11233 $as_echo_n "checking for $ac_word... " >&6; }
11234 if ${ac_cv_path_UNAME+:} false; then :
11235   $as_echo_n "(cached) " >&6
11236 else
11237   case $UNAME in
11238   [\\/]* | ?:[\\/]*)
11239   ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
11240   ;;
11241   *)
11242   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11243 for as_dir in $PATH
11244 do
11245   IFS=$as_save_IFS
11246   test -z "$as_dir" && as_dir=.
11247     for ac_exec_ext in '' $ac_executable_extensions; do
11248   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11249     ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
11250     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11251     break 2
11252   fi
11253 done
11254   done
11255 IFS=$as_save_IFS
11256 
11257   ;;
11258 esac
11259 fi
11260 UNAME=$ac_cv_path_UNAME
11261 if test -n "$UNAME"; then
11262   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
11263 $as_echo "$UNAME" >&6; }
11264 else
11265   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11266 $as_echo "no" >&6; }
11267 fi
11268 
11269 
11270   test -n "$UNAME" && break
11271 done
11272 
11273   else
11274     # The variable is set, but is it from the command line or the environment?
11275 
11276     # Try to remove the string !UNAME! from our list.
11277     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNAME!/}
11278     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11279       # If it failed, the variable was not from the command line. Ignore it,
11280       # but warn the user (except for BASH, which is always set by the calling BASH).
11281       if test "xUNAME" != xBASH; then
11282         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNAME from the environment. Use command line variables instead." >&5
11283 $as_echo "$as_me: WARNING: Ignoring value of UNAME from the environment. Use command line variables instead." >&2;}
11284       fi
11285       # Try to locate tool using the code snippet
11286       for ac_prog in uname
11287 do
11288   # Extract the first word of "$ac_prog", so it can be a program name with args.
11289 set dummy $ac_prog; ac_word=$2
11290 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11291 $as_echo_n "checking for $ac_word... " >&6; }
11292 if ${ac_cv_path_UNAME+:} false; then :
11293   $as_echo_n "(cached) " >&6
11294 else
11295   case $UNAME in
11296   [\\/]* | ?:[\\/]*)
11297   ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
11298   ;;
11299   *)
11300   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11301 for as_dir in $PATH
11302 do
11303   IFS=$as_save_IFS
11304   test -z "$as_dir" && as_dir=.
11305     for ac_exec_ext in '' $ac_executable_extensions; do
11306   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11307     ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
11308     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11309     break 2
11310   fi
11311 done
11312   done
11313 IFS=$as_save_IFS
11314 
11315   ;;
11316 esac
11317 fi
11318 UNAME=$ac_cv_path_UNAME
11319 if test -n "$UNAME"; then
11320   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
11321 $as_echo "$UNAME" >&6; }
11322 else
11323   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11324 $as_echo "no" >&6; }
11325 fi
11326 
11327 
11328   test -n "$UNAME" && break
11329 done
11330 
11331     else
11332       # If it succeeded, then it was overridden by the user. We will use it
11333       # for the tool.
11334 
11335       # First remove it from the list of overridden variables, so we can test
11336       # for unknown variables in the end.
11337       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11338 
11339       # Check if we try to supply an empty value
11340       if test "x$UNAME" = x; then
11341         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool UNAME= (no value)" >&5
11342 $as_echo "$as_me: Setting user supplied tool UNAME= (no value)" >&6;}
11343         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNAME" >&5
11344 $as_echo_n "checking for UNAME... " >&6; }
11345         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
11346 $as_echo "disabled" >&6; }
11347       else
11348         # Check if the provided tool contains a complete path.
11349         tool_specified="$UNAME"
11350         tool_basename="${tool_specified##*/}"
11351         if test "x$tool_basename" = "x$tool_specified"; then
11352           # A command without a complete path is provided, search $PATH.
11353           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNAME=$tool_basename" >&5
11354 $as_echo "$as_me: Will search for user supplied tool UNAME=$tool_basename" >&6;}
11355           # Extract the first word of "$tool_basename", so it can be a program name with args.
11356 set dummy $tool_basename; ac_word=$2
11357 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11358 $as_echo_n "checking for $ac_word... " >&6; }
11359 if ${ac_cv_path_UNAME+:} false; then :
11360   $as_echo_n "(cached) " >&6
11361 else
11362   case $UNAME in
11363   [\\/]* | ?:[\\/]*)
11364   ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
11365   ;;
11366   *)
11367   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11368 for as_dir in $PATH
11369 do
11370   IFS=$as_save_IFS
11371   test -z "$as_dir" && as_dir=.
11372     for ac_exec_ext in '' $ac_executable_extensions; do
11373   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11374     ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
11375     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11376     break 2
11377   fi
11378 done
11379   done
11380 IFS=$as_save_IFS
11381 
11382   ;;
11383 esac
11384 fi
11385 UNAME=$ac_cv_path_UNAME
11386 if test -n "$UNAME"; then
11387   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
11388 $as_echo "$UNAME" >&6; }
11389 else
11390   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11391 $as_echo "no" >&6; }
11392 fi
11393 
11394 
11395           if test "x$UNAME" = x; then
11396             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11397           fi
11398         else
11399           # Otherwise we believe it is a complete path. Use it as it is.
11400           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNAME=$tool_specified" >&5
11401 $as_echo "$as_me: Will use user supplied tool UNAME=$tool_specified" >&6;}
11402           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNAME" >&5
11403 $as_echo_n "checking for UNAME... " >&6; }
11404           if test ! -x "$tool_specified"; then
11405             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11406 $as_echo "not found" >&6; }
11407             as_fn_error $? "User supplied tool UNAME=$tool_specified does not exist or is not executable" "$LINENO" 5
11408           fi
11409           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11410 $as_echo "$tool_specified" >&6; }
11411         fi
11412       fi
11413     fi
11414 
11415   fi
11416 
11417 
11418 
11419   if test "x$UNAME" = x; then
11420     as_fn_error $? "Could not find required tool for UNAME" "$LINENO" 5
11421   fi
11422 
11423 
11424 
11425 
11426 
11427   # Publish this variable in the help.
11428 
11429 
11430   if [ -z "${UNIQ+x}" ]; then
11431     # The variable is not set by user, try to locate tool using the code snippet
11432     for ac_prog in uniq
11433 do
11434   # Extract the first word of "$ac_prog", so it can be a program name with args.
11435 set dummy $ac_prog; ac_word=$2
11436 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11437 $as_echo_n "checking for $ac_word... " >&6; }
11438 if ${ac_cv_path_UNIQ+:} false; then :
11439   $as_echo_n "(cached) " >&6
11440 else
11441   case $UNIQ in
11442   [\\/]* | ?:[\\/]*)
11443   ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
11444   ;;
11445   *)
11446   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11447 for as_dir in $PATH
11448 do
11449   IFS=$as_save_IFS
11450   test -z "$as_dir" && as_dir=.
11451     for ac_exec_ext in '' $ac_executable_extensions; do
11452   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11453     ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
11454     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11455     break 2
11456   fi
11457 done
11458   done
11459 IFS=$as_save_IFS
11460 
11461   ;;
11462 esac
11463 fi
11464 UNIQ=$ac_cv_path_UNIQ
11465 if test -n "$UNIQ"; then
11466   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
11467 $as_echo "$UNIQ" >&6; }
11468 else
11469   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11470 $as_echo "no" >&6; }
11471 fi
11472 
11473 
11474   test -n "$UNIQ" && break
11475 done
11476 
11477   else
11478     # The variable is set, but is it from the command line or the environment?
11479 
11480     # Try to remove the string !UNIQ! from our list.
11481     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNIQ!/}
11482     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11483       # If it failed, the variable was not from the command line. Ignore it,
11484       # but warn the user (except for BASH, which is always set by the calling BASH).
11485       if test "xUNIQ" != xBASH; then
11486         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNIQ from the environment. Use command line variables instead." >&5
11487 $as_echo "$as_me: WARNING: Ignoring value of UNIQ from the environment. Use command line variables instead." >&2;}
11488       fi
11489       # Try to locate tool using the code snippet
11490       for ac_prog in uniq
11491 do
11492   # Extract the first word of "$ac_prog", so it can be a program name with args.
11493 set dummy $ac_prog; ac_word=$2
11494 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11495 $as_echo_n "checking for $ac_word... " >&6; }
11496 if ${ac_cv_path_UNIQ+:} false; then :
11497   $as_echo_n "(cached) " >&6
11498 else
11499   case $UNIQ in
11500   [\\/]* | ?:[\\/]*)
11501   ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
11502   ;;
11503   *)
11504   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11505 for as_dir in $PATH
11506 do
11507   IFS=$as_save_IFS
11508   test -z "$as_dir" && as_dir=.
11509     for ac_exec_ext in '' $ac_executable_extensions; do
11510   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11511     ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
11512     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11513     break 2
11514   fi
11515 done
11516   done
11517 IFS=$as_save_IFS
11518 
11519   ;;
11520 esac
11521 fi
11522 UNIQ=$ac_cv_path_UNIQ
11523 if test -n "$UNIQ"; then
11524   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
11525 $as_echo "$UNIQ" >&6; }
11526 else
11527   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11528 $as_echo "no" >&6; }
11529 fi
11530 
11531 
11532   test -n "$UNIQ" && break
11533 done
11534 
11535     else
11536       # If it succeeded, then it was overridden by the user. We will use it
11537       # for the tool.
11538 
11539       # First remove it from the list of overridden variables, so we can test
11540       # for unknown variables in the end.
11541       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11542 
11543       # Check if we try to supply an empty value
11544       if test "x$UNIQ" = x; then
11545         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool UNIQ= (no value)" >&5
11546 $as_echo "$as_me: Setting user supplied tool UNIQ= (no value)" >&6;}
11547         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNIQ" >&5
11548 $as_echo_n "checking for UNIQ... " >&6; }
11549         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
11550 $as_echo "disabled" >&6; }
11551       else
11552         # Check if the provided tool contains a complete path.
11553         tool_specified="$UNIQ"
11554         tool_basename="${tool_specified##*/}"
11555         if test "x$tool_basename" = "x$tool_specified"; then
11556           # A command without a complete path is provided, search $PATH.
11557           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNIQ=$tool_basename" >&5
11558 $as_echo "$as_me: Will search for user supplied tool UNIQ=$tool_basename" >&6;}
11559           # Extract the first word of "$tool_basename", so it can be a program name with args.
11560 set dummy $tool_basename; ac_word=$2
11561 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11562 $as_echo_n "checking for $ac_word... " >&6; }
11563 if ${ac_cv_path_UNIQ+:} false; then :
11564   $as_echo_n "(cached) " >&6
11565 else
11566   case $UNIQ in
11567   [\\/]* | ?:[\\/]*)
11568   ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
11569   ;;
11570   *)
11571   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11572 for as_dir in $PATH
11573 do
11574   IFS=$as_save_IFS
11575   test -z "$as_dir" && as_dir=.
11576     for ac_exec_ext in '' $ac_executable_extensions; do
11577   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11578     ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
11579     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11580     break 2
11581   fi
11582 done
11583   done
11584 IFS=$as_save_IFS
11585 
11586   ;;
11587 esac
11588 fi
11589 UNIQ=$ac_cv_path_UNIQ
11590 if test -n "$UNIQ"; then
11591   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
11592 $as_echo "$UNIQ" >&6; }
11593 else
11594   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11595 $as_echo "no" >&6; }
11596 fi
11597 
11598 
11599           if test "x$UNIQ" = x; then
11600             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11601           fi
11602         else
11603           # Otherwise we believe it is a complete path. Use it as it is.
11604           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNIQ=$tool_specified" >&5
11605 $as_echo "$as_me: Will use user supplied tool UNIQ=$tool_specified" >&6;}
11606           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNIQ" >&5
11607 $as_echo_n "checking for UNIQ... " >&6; }
11608           if test ! -x "$tool_specified"; then
11609             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11610 $as_echo "not found" >&6; }
11611             as_fn_error $? "User supplied tool UNIQ=$tool_specified does not exist or is not executable" "$LINENO" 5
11612           fi
11613           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11614 $as_echo "$tool_specified" >&6; }
11615         fi
11616       fi
11617     fi
11618 
11619   fi
11620 
11621 
11622 
11623   if test "x$UNIQ" = x; then
11624     as_fn_error $? "Could not find required tool for UNIQ" "$LINENO" 5
11625   fi
11626 
11627 
11628 
11629 
11630 
11631   # Publish this variable in the help.
11632 
11633 
11634   if [ -z "${WC+x}" ]; then
11635     # The variable is not set by user, try to locate tool using the code snippet
11636     for ac_prog in wc
11637 do
11638   # Extract the first word of "$ac_prog", so it can be a program name with args.
11639 set dummy $ac_prog; ac_word=$2
11640 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11641 $as_echo_n "checking for $ac_word... " >&6; }
11642 if ${ac_cv_path_WC+:} false; then :
11643   $as_echo_n "(cached) " >&6
11644 else
11645   case $WC in
11646   [\\/]* | ?:[\\/]*)
11647   ac_cv_path_WC="$WC" # Let the user override the test with a path.
11648   ;;
11649   *)
11650   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11651 for as_dir in $PATH
11652 do
11653   IFS=$as_save_IFS
11654   test -z "$as_dir" && as_dir=.
11655     for ac_exec_ext in '' $ac_executable_extensions; do
11656   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11657     ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
11658     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11659     break 2
11660   fi
11661 done
11662   done
11663 IFS=$as_save_IFS
11664 
11665   ;;
11666 esac
11667 fi
11668 WC=$ac_cv_path_WC
11669 if test -n "$WC"; then
11670   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
11671 $as_echo "$WC" >&6; }
11672 else
11673   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11674 $as_echo "no" >&6; }
11675 fi
11676 
11677 
11678   test -n "$WC" && break
11679 done
11680 
11681   else
11682     # The variable is set, but is it from the command line or the environment?
11683 
11684     # Try to remove the string !WC! from our list.
11685     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!WC!/}
11686     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11687       # If it failed, the variable was not from the command line. Ignore it,
11688       # but warn the user (except for BASH, which is always set by the calling BASH).
11689       if test "xWC" != xBASH; then
11690         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of WC from the environment. Use command line variables instead." >&5
11691 $as_echo "$as_me: WARNING: Ignoring value of WC from the environment. Use command line variables instead." >&2;}
11692       fi
11693       # Try to locate tool using the code snippet
11694       for ac_prog in wc
11695 do
11696   # Extract the first word of "$ac_prog", so it can be a program name with args.
11697 set dummy $ac_prog; ac_word=$2
11698 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11699 $as_echo_n "checking for $ac_word... " >&6; }
11700 if ${ac_cv_path_WC+:} false; then :
11701   $as_echo_n "(cached) " >&6
11702 else
11703   case $WC in
11704   [\\/]* | ?:[\\/]*)
11705   ac_cv_path_WC="$WC" # Let the user override the test with a path.
11706   ;;
11707   *)
11708   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11709 for as_dir in $PATH
11710 do
11711   IFS=$as_save_IFS
11712   test -z "$as_dir" && as_dir=.
11713     for ac_exec_ext in '' $ac_executable_extensions; do
11714   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11715     ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
11716     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11717     break 2
11718   fi
11719 done
11720   done
11721 IFS=$as_save_IFS
11722 
11723   ;;
11724 esac
11725 fi
11726 WC=$ac_cv_path_WC
11727 if test -n "$WC"; then
11728   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
11729 $as_echo "$WC" >&6; }
11730 else
11731   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11732 $as_echo "no" >&6; }
11733 fi
11734 
11735 
11736   test -n "$WC" && break
11737 done
11738 
11739     else
11740       # If it succeeded, then it was overridden by the user. We will use it
11741       # for the tool.
11742 
11743       # First remove it from the list of overridden variables, so we can test
11744       # for unknown variables in the end.
11745       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11746 
11747       # Check if we try to supply an empty value
11748       if test "x$WC" = x; then
11749         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool WC= (no value)" >&5
11750 $as_echo "$as_me: Setting user supplied tool WC= (no value)" >&6;}
11751         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WC" >&5
11752 $as_echo_n "checking for WC... " >&6; }
11753         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
11754 $as_echo "disabled" >&6; }
11755       else
11756         # Check if the provided tool contains a complete path.
11757         tool_specified="$WC"
11758         tool_basename="${tool_specified##*/}"
11759         if test "x$tool_basename" = "x$tool_specified"; then
11760           # A command without a complete path is provided, search $PATH.
11761           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool WC=$tool_basename" >&5
11762 $as_echo "$as_me: Will search for user supplied tool WC=$tool_basename" >&6;}
11763           # Extract the first word of "$tool_basename", so it can be a program name with args.
11764 set dummy $tool_basename; ac_word=$2
11765 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11766 $as_echo_n "checking for $ac_word... " >&6; }
11767 if ${ac_cv_path_WC+:} false; then :
11768   $as_echo_n "(cached) " >&6
11769 else
11770   case $WC in
11771   [\\/]* | ?:[\\/]*)
11772   ac_cv_path_WC="$WC" # Let the user override the test with a path.
11773   ;;
11774   *)
11775   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11776 for as_dir in $PATH
11777 do
11778   IFS=$as_save_IFS
11779   test -z "$as_dir" && as_dir=.
11780     for ac_exec_ext in '' $ac_executable_extensions; do
11781   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11782     ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
11783     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11784     break 2
11785   fi
11786 done
11787   done
11788 IFS=$as_save_IFS
11789 
11790   ;;
11791 esac
11792 fi
11793 WC=$ac_cv_path_WC
11794 if test -n "$WC"; then
11795   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
11796 $as_echo "$WC" >&6; }
11797 else
11798   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11799 $as_echo "no" >&6; }
11800 fi
11801 
11802 
11803           if test "x$WC" = x; then
11804             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11805           fi
11806         else
11807           # Otherwise we believe it is a complete path. Use it as it is.
11808           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool WC=$tool_specified" >&5
11809 $as_echo "$as_me: Will use user supplied tool WC=$tool_specified" >&6;}
11810           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WC" >&5
11811 $as_echo_n "checking for WC... " >&6; }
11812           if test ! -x "$tool_specified"; then
11813             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11814 $as_echo "not found" >&6; }
11815             as_fn_error $? "User supplied tool WC=$tool_specified does not exist or is not executable" "$LINENO" 5
11816           fi
11817           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11818 $as_echo "$tool_specified" >&6; }
11819         fi
11820       fi
11821     fi
11822 
11823   fi
11824 
11825 
11826 
11827   if test "x$WC" = x; then
11828     as_fn_error $? "Could not find required tool for WC" "$LINENO" 5
11829   fi
11830 
11831 
11832 
11833 
11834 
11835   # Publish this variable in the help.
11836 
11837 
11838   if [ -z "${WHICH+x}" ]; then
11839     # The variable is not set by user, try to locate tool using the code snippet
11840     for ac_prog in which
11841 do
11842   # Extract the first word of "$ac_prog", so it can be a program name with args.
11843 set dummy $ac_prog; ac_word=$2
11844 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11845 $as_echo_n "checking for $ac_word... " >&6; }
11846 if ${ac_cv_path_WHICH+:} false; then :
11847   $as_echo_n "(cached) " >&6
11848 else
11849   case $WHICH in
11850   [\\/]* | ?:[\\/]*)
11851   ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
11852   ;;
11853   *)
11854   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11855 for as_dir in $PATH
11856 do
11857   IFS=$as_save_IFS
11858   test -z "$as_dir" && as_dir=.
11859     for ac_exec_ext in '' $ac_executable_extensions; do
11860   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11861     ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
11862     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11863     break 2
11864   fi
11865 done
11866   done
11867 IFS=$as_save_IFS
11868 
11869   ;;
11870 esac
11871 fi
11872 WHICH=$ac_cv_path_WHICH
11873 if test -n "$WHICH"; then
11874   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
11875 $as_echo "$WHICH" >&6; }
11876 else
11877   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11878 $as_echo "no" >&6; }
11879 fi
11880 
11881 
11882   test -n "$WHICH" && break
11883 done
11884 
11885   else
11886     # The variable is set, but is it from the command line or the environment?
11887 
11888     # Try to remove the string !WHICH! from our list.
11889     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!WHICH!/}
11890     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11891       # If it failed, the variable was not from the command line. Ignore it,
11892       # but warn the user (except for BASH, which is always set by the calling BASH).
11893       if test "xWHICH" != xBASH; then
11894         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of WHICH from the environment. Use command line variables instead." >&5
11895 $as_echo "$as_me: WARNING: Ignoring value of WHICH from the environment. Use command line variables instead." >&2;}
11896       fi
11897       # Try to locate tool using the code snippet
11898       for ac_prog in which
11899 do
11900   # Extract the first word of "$ac_prog", so it can be a program name with args.
11901 set dummy $ac_prog; ac_word=$2
11902 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11903 $as_echo_n "checking for $ac_word... " >&6; }
11904 if ${ac_cv_path_WHICH+:} false; then :
11905   $as_echo_n "(cached) " >&6
11906 else
11907   case $WHICH in
11908   [\\/]* | ?:[\\/]*)
11909   ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
11910   ;;
11911   *)
11912   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11913 for as_dir in $PATH
11914 do
11915   IFS=$as_save_IFS
11916   test -z "$as_dir" && as_dir=.
11917     for ac_exec_ext in '' $ac_executable_extensions; do
11918   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11919     ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
11920     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11921     break 2
11922   fi
11923 done
11924   done
11925 IFS=$as_save_IFS
11926 
11927   ;;
11928 esac
11929 fi
11930 WHICH=$ac_cv_path_WHICH
11931 if test -n "$WHICH"; then
11932   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
11933 $as_echo "$WHICH" >&6; }
11934 else
11935   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11936 $as_echo "no" >&6; }
11937 fi
11938 
11939 
11940   test -n "$WHICH" && break
11941 done
11942 
11943     else
11944       # If it succeeded, then it was overridden by the user. We will use it
11945       # for the tool.
11946 
11947       # First remove it from the list of overridden variables, so we can test
11948       # for unknown variables in the end.
11949       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11950 
11951       # Check if we try to supply an empty value
11952       if test "x$WHICH" = x; then
11953         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool WHICH= (no value)" >&5
11954 $as_echo "$as_me: Setting user supplied tool WHICH= (no value)" >&6;}
11955         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WHICH" >&5
11956 $as_echo_n "checking for WHICH... " >&6; }
11957         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
11958 $as_echo "disabled" >&6; }
11959       else
11960         # Check if the provided tool contains a complete path.
11961         tool_specified="$WHICH"
11962         tool_basename="${tool_specified##*/}"
11963         if test "x$tool_basename" = "x$tool_specified"; then
11964           # A command without a complete path is provided, search $PATH.
11965           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool WHICH=$tool_basename" >&5
11966 $as_echo "$as_me: Will search for user supplied tool WHICH=$tool_basename" >&6;}
11967           # Extract the first word of "$tool_basename", so it can be a program name with args.
11968 set dummy $tool_basename; ac_word=$2
11969 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11970 $as_echo_n "checking for $ac_word... " >&6; }
11971 if ${ac_cv_path_WHICH+:} false; then :
11972   $as_echo_n "(cached) " >&6
11973 else
11974   case $WHICH in
11975   [\\/]* | ?:[\\/]*)
11976   ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
11977   ;;
11978   *)
11979   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11980 for as_dir in $PATH
11981 do
11982   IFS=$as_save_IFS
11983   test -z "$as_dir" && as_dir=.
11984     for ac_exec_ext in '' $ac_executable_extensions; do
11985   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11986     ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
11987     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11988     break 2
11989   fi
11990 done
11991   done
11992 IFS=$as_save_IFS
11993 
11994   ;;
11995 esac
11996 fi
11997 WHICH=$ac_cv_path_WHICH
11998 if test -n "$WHICH"; then
11999   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
12000 $as_echo "$WHICH" >&6; }
12001 else
12002   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12003 $as_echo "no" >&6; }
12004 fi
12005 
12006 
12007           if test "x$WHICH" = x; then
12008             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12009           fi
12010         else
12011           # Otherwise we believe it is a complete path. Use it as it is.
12012           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool WHICH=$tool_specified" >&5
12013 $as_echo "$as_me: Will use user supplied tool WHICH=$tool_specified" >&6;}
12014           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WHICH" >&5
12015 $as_echo_n "checking for WHICH... " >&6; }
12016           if test ! -x "$tool_specified"; then
12017             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12018 $as_echo "not found" >&6; }
12019             as_fn_error $? "User supplied tool WHICH=$tool_specified does not exist or is not executable" "$LINENO" 5
12020           fi
12021           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12022 $as_echo "$tool_specified" >&6; }
12023         fi
12024       fi
12025     fi
12026 
12027   fi
12028 
12029 
12030 
12031   if test "x$WHICH" = x; then
12032     as_fn_error $? "Could not find required tool for WHICH" "$LINENO" 5
12033   fi
12034 
12035 
12036 
12037 
12038 
12039   # Publish this variable in the help.
12040 
12041 
12042   if [ -z "${XARGS+x}" ]; then
12043     # The variable is not set by user, try to locate tool using the code snippet
12044     for ac_prog in xargs
12045 do
12046   # Extract the first word of "$ac_prog", so it can be a program name with args.
12047 set dummy $ac_prog; ac_word=$2
12048 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12049 $as_echo_n "checking for $ac_word... " >&6; }
12050 if ${ac_cv_path_XARGS+:} false; then :
12051   $as_echo_n "(cached) " >&6
12052 else
12053   case $XARGS in
12054   [\\/]* | ?:[\\/]*)
12055   ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
12056   ;;
12057   *)
12058   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12059 for as_dir in $PATH
12060 do
12061   IFS=$as_save_IFS
12062   test -z "$as_dir" && as_dir=.
12063     for ac_exec_ext in '' $ac_executable_extensions; do
12064   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12065     ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
12066     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12067     break 2
12068   fi
12069 done
12070   done
12071 IFS=$as_save_IFS
12072 
12073   ;;
12074 esac
12075 fi
12076 XARGS=$ac_cv_path_XARGS
12077 if test -n "$XARGS"; then
12078   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
12079 $as_echo "$XARGS" >&6; }
12080 else
12081   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12082 $as_echo "no" >&6; }
12083 fi
12084 
12085 
12086   test -n "$XARGS" && break
12087 done
12088 
12089   else
12090     # The variable is set, but is it from the command line or the environment?
12091 
12092     # Try to remove the string !XARGS! from our list.
12093     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!XARGS!/}
12094     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12095       # If it failed, the variable was not from the command line. Ignore it,
12096       # but warn the user (except for BASH, which is always set by the calling BASH).
12097       if test "xXARGS" != xBASH; then
12098         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of XARGS from the environment. Use command line variables instead." >&5
12099 $as_echo "$as_me: WARNING: Ignoring value of XARGS from the environment. Use command line variables instead." >&2;}
12100       fi
12101       # Try to locate tool using the code snippet
12102       for ac_prog in xargs
12103 do
12104   # Extract the first word of "$ac_prog", so it can be a program name with args.
12105 set dummy $ac_prog; ac_word=$2
12106 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12107 $as_echo_n "checking for $ac_word... " >&6; }
12108 if ${ac_cv_path_XARGS+:} false; then :
12109   $as_echo_n "(cached) " >&6
12110 else
12111   case $XARGS in
12112   [\\/]* | ?:[\\/]*)
12113   ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
12114   ;;
12115   *)
12116   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12117 for as_dir in $PATH
12118 do
12119   IFS=$as_save_IFS
12120   test -z "$as_dir" && as_dir=.
12121     for ac_exec_ext in '' $ac_executable_extensions; do
12122   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12123     ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
12124     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12125     break 2
12126   fi
12127 done
12128   done
12129 IFS=$as_save_IFS
12130 
12131   ;;
12132 esac
12133 fi
12134 XARGS=$ac_cv_path_XARGS
12135 if test -n "$XARGS"; then
12136   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
12137 $as_echo "$XARGS" >&6; }
12138 else
12139   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12140 $as_echo "no" >&6; }
12141 fi
12142 
12143 
12144   test -n "$XARGS" && break
12145 done
12146 
12147     else
12148       # If it succeeded, then it was overridden by the user. We will use it
12149       # for the tool.
12150 
12151       # First remove it from the list of overridden variables, so we can test
12152       # for unknown variables in the end.
12153       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12154 
12155       # Check if we try to supply an empty value
12156       if test "x$XARGS" = x; then
12157         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool XARGS= (no value)" >&5
12158 $as_echo "$as_me: Setting user supplied tool XARGS= (no value)" >&6;}
12159         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XARGS" >&5
12160 $as_echo_n "checking for XARGS... " >&6; }
12161         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
12162 $as_echo "disabled" >&6; }
12163       else
12164         # Check if the provided tool contains a complete path.
12165         tool_specified="$XARGS"
12166         tool_basename="${tool_specified##*/}"
12167         if test "x$tool_basename" = "x$tool_specified"; then
12168           # A command without a complete path is provided, search $PATH.
12169           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool XARGS=$tool_basename" >&5
12170 $as_echo "$as_me: Will search for user supplied tool XARGS=$tool_basename" >&6;}
12171           # Extract the first word of "$tool_basename", so it can be a program name with args.
12172 set dummy $tool_basename; ac_word=$2
12173 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12174 $as_echo_n "checking for $ac_word... " >&6; }
12175 if ${ac_cv_path_XARGS+:} false; then :
12176   $as_echo_n "(cached) " >&6
12177 else
12178   case $XARGS in
12179   [\\/]* | ?:[\\/]*)
12180   ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
12181   ;;
12182   *)
12183   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12184 for as_dir in $PATH
12185 do
12186   IFS=$as_save_IFS
12187   test -z "$as_dir" && as_dir=.
12188     for ac_exec_ext in '' $ac_executable_extensions; do
12189   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12190     ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
12191     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12192     break 2
12193   fi
12194 done
12195   done
12196 IFS=$as_save_IFS
12197 
12198   ;;
12199 esac
12200 fi
12201 XARGS=$ac_cv_path_XARGS
12202 if test -n "$XARGS"; then
12203   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
12204 $as_echo "$XARGS" >&6; }
12205 else
12206   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12207 $as_echo "no" >&6; }
12208 fi
12209 
12210 
12211           if test "x$XARGS" = x; then
12212             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12213           fi
12214         else
12215           # Otherwise we believe it is a complete path. Use it as it is.
12216           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool XARGS=$tool_specified" >&5
12217 $as_echo "$as_me: Will use user supplied tool XARGS=$tool_specified" >&6;}
12218           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XARGS" >&5
12219 $as_echo_n "checking for XARGS... " >&6; }
12220           if test ! -x "$tool_specified"; then
12221             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12222 $as_echo "not found" >&6; }
12223             as_fn_error $? "User supplied tool XARGS=$tool_specified does not exist or is not executable" "$LINENO" 5
12224           fi
12225           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12226 $as_echo "$tool_specified" >&6; }
12227         fi
12228       fi
12229     fi
12230 
12231   fi
12232 
12233 
12234 
12235   if test "x$XARGS" = x; then
12236     as_fn_error $? "Could not find required tool for XARGS" "$LINENO" 5
12237   fi
12238 
12239 
12240 
12241   # Then required tools that require some special treatment.
12242 
12243 
12244   # Publish this variable in the help.
12245 
12246 
12247   if [ -z "${AWK+x}" ]; then
12248     # The variable is not set by user, try to locate tool using the code snippet
12249     for ac_prog in gawk mawk nawk awk
12250 do
12251   # Extract the first word of "$ac_prog", so it can be a program name with args.
12252 set dummy $ac_prog; ac_word=$2
12253 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12254 $as_echo_n "checking for $ac_word... " >&6; }
12255 if ${ac_cv_prog_AWK+:} false; then :
12256   $as_echo_n "(cached) " >&6
12257 else
12258   if test -n "$AWK"; then
12259   ac_cv_prog_AWK="$AWK" # Let the user override the test.
12260 else
12261 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12262 for as_dir in $PATH
12263 do
12264   IFS=$as_save_IFS
12265   test -z "$as_dir" && as_dir=.
12266     for ac_exec_ext in '' $ac_executable_extensions; do
12267   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12268     ac_cv_prog_AWK="$ac_prog"
12269     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12270     break 2
12271   fi
12272 done
12273   done
12274 IFS=$as_save_IFS
12275 
12276 fi
12277 fi
12278 AWK=$ac_cv_prog_AWK
12279 if test -n "$AWK"; then
12280   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
12281 $as_echo "$AWK" >&6; }
12282 else
12283   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12284 $as_echo "no" >&6; }
12285 fi
12286 
12287 
12288   test -n "$AWK" && break
12289 done
12290 
12291   else
12292     # The variable is set, but is it from the command line or the environment?
12293 
12294     # Try to remove the string !AWK! from our list.
12295     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!AWK!/}
12296     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12297       # If it failed, the variable was not from the command line. Ignore it,
12298       # but warn the user (except for BASH, which is always set by the calling BASH).
12299       if test "xAWK" != xBASH; then
12300         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of AWK from the environment. Use command line variables instead." >&5
12301 $as_echo "$as_me: WARNING: Ignoring value of AWK from the environment. Use command line variables instead." >&2;}
12302       fi
12303       # Try to locate tool using the code snippet
12304       for ac_prog in gawk mawk nawk awk
12305 do
12306   # Extract the first word of "$ac_prog", so it can be a program name with args.
12307 set dummy $ac_prog; ac_word=$2
12308 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12309 $as_echo_n "checking for $ac_word... " >&6; }
12310 if ${ac_cv_prog_AWK+:} false; then :
12311   $as_echo_n "(cached) " >&6
12312 else
12313   if test -n "$AWK"; then
12314   ac_cv_prog_AWK="$AWK" # Let the user override the test.
12315 else
12316 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12317 for as_dir in $PATH
12318 do
12319   IFS=$as_save_IFS
12320   test -z "$as_dir" && as_dir=.
12321     for ac_exec_ext in '' $ac_executable_extensions; do
12322   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12323     ac_cv_prog_AWK="$ac_prog"
12324     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12325     break 2
12326   fi
12327 done
12328   done
12329 IFS=$as_save_IFS
12330 
12331 fi
12332 fi
12333 AWK=$ac_cv_prog_AWK
12334 if test -n "$AWK"; then
12335   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
12336 $as_echo "$AWK" >&6; }
12337 else
12338   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12339 $as_echo "no" >&6; }
12340 fi
12341 
12342 
12343   test -n "$AWK" && break
12344 done
12345 
12346     else
12347       # If it succeeded, then it was overridden by the user. We will use it
12348       # for the tool.
12349 
12350       # First remove it from the list of overridden variables, so we can test
12351       # for unknown variables in the end.
12352       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12353 
12354       # Check if we try to supply an empty value
12355       if test "x$AWK" = x; then
12356         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool AWK= (no value)" >&5
12357 $as_echo "$as_me: Setting user supplied tool AWK= (no value)" >&6;}
12358         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for AWK" >&5
12359 $as_echo_n "checking for AWK... " >&6; }
12360         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
12361 $as_echo "disabled" >&6; }
12362       else
12363         # Check if the provided tool contains a complete path.
12364         tool_specified="$AWK"
12365         tool_basename="${tool_specified##*/}"
12366         if test "x$tool_basename" = "x$tool_specified"; then
12367           # A command without a complete path is provided, search $PATH.
12368           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool AWK=$tool_basename" >&5
12369 $as_echo "$as_me: Will search for user supplied tool AWK=$tool_basename" >&6;}
12370           # Extract the first word of "$tool_basename", so it can be a program name with args.
12371 set dummy $tool_basename; ac_word=$2
12372 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12373 $as_echo_n "checking for $ac_word... " >&6; }
12374 if ${ac_cv_path_AWK+:} false; then :
12375   $as_echo_n "(cached) " >&6
12376 else
12377   case $AWK in
12378   [\\/]* | ?:[\\/]*)
12379   ac_cv_path_AWK="$AWK" # Let the user override the test with a path.
12380   ;;
12381   *)
12382   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12383 for as_dir in $PATH
12384 do
12385   IFS=$as_save_IFS
12386   test -z "$as_dir" && as_dir=.
12387     for ac_exec_ext in '' $ac_executable_extensions; do
12388   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12389     ac_cv_path_AWK="$as_dir/$ac_word$ac_exec_ext"
12390     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12391     break 2
12392   fi
12393 done
12394   done
12395 IFS=$as_save_IFS
12396 
12397   ;;
12398 esac
12399 fi
12400 AWK=$ac_cv_path_AWK
12401 if test -n "$AWK"; then
12402   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
12403 $as_echo "$AWK" >&6; }
12404 else
12405   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12406 $as_echo "no" >&6; }
12407 fi
12408 
12409 
12410           if test "x$AWK" = x; then
12411             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12412           fi
12413         else
12414           # Otherwise we believe it is a complete path. Use it as it is.
12415           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool AWK=$tool_specified" >&5
12416 $as_echo "$as_me: Will use user supplied tool AWK=$tool_specified" >&6;}
12417           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for AWK" >&5
12418 $as_echo_n "checking for AWK... " >&6; }
12419           if test ! -x "$tool_specified"; then
12420             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12421 $as_echo "not found" >&6; }
12422             as_fn_error $? "User supplied tool AWK=$tool_specified does not exist or is not executable" "$LINENO" 5
12423           fi
12424           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12425 $as_echo "$tool_specified" >&6; }
12426         fi
12427       fi
12428     fi
12429 
12430   fi
12431 
12432 
12433   if test "x$AWK" = x; then
12434     as_fn_error $? "Could not find required tool for AWK" "$LINENO" 5
12435   fi
12436 
12437 
12438 
12439 
12440   # Publish this variable in the help.
12441 
12442 
12443   if [ -z "${GREP+x}" ]; then
12444     # The variable is not set by user, try to locate tool using the code snippet
12445     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
12446 $as_echo_n "checking for grep that handles long lines and -e... " >&6; }
12447 if ${ac_cv_path_GREP+:} false; then :
12448   $as_echo_n "(cached) " >&6
12449 else
12450   if test -z "$GREP"; then
12451   ac_path_GREP_found=false
12452   # Loop through the user's path and test for each of PROGNAME-LIST
12453   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12454 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
12455 do
12456   IFS=$as_save_IFS
12457   test -z "$as_dir" && as_dir=.
12458     for ac_prog in grep ggrep; do
12459     for ac_exec_ext in '' $ac_executable_extensions; do
12460       ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
12461       as_fn_executable_p "$ac_path_GREP" || continue
12462 # Check for GNU ac_path_GREP and select it if it is found.
12463   # Check for GNU $ac_path_GREP
12464 case `"$ac_path_GREP" --version 2>&1` in
12465 *GNU*)
12466   ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
12467 *)
12468   ac_count=0
12469   $as_echo_n 0123456789 >"conftest.in"
12470   while :
12471   do
12472     cat "conftest.in" "conftest.in" >"conftest.tmp"
12473     mv "conftest.tmp" "conftest.in"
12474     cp "conftest.in" "conftest.nl"
12475     $as_echo 'GREP' >> "conftest.nl"
12476     "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
12477     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12478     as_fn_arith $ac_count + 1 && ac_count=$as_val
12479     if test $ac_count -gt ${ac_path_GREP_max-0}; then
12480       # Best one so far, save it but keep looking for a better one
12481       ac_cv_path_GREP="$ac_path_GREP"
12482       ac_path_GREP_max=$ac_count
12483     fi
12484     # 10*(2^10) chars as input seems more than enough
12485     test $ac_count -gt 10 && break
12486   done
12487   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12488 esac
12489 
12490       $ac_path_GREP_found && break 3
12491     done
12492   done
12493   done
12494 IFS=$as_save_IFS
12495   if test -z "$ac_cv_path_GREP"; then
12496     as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
12497   fi
12498 else
12499   ac_cv_path_GREP=$GREP
12500 fi
12501 
12502 fi
12503 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
12504 $as_echo "$ac_cv_path_GREP" >&6; }
12505  GREP="$ac_cv_path_GREP"
12506 
12507 
12508   else
12509     # The variable is set, but is it from the command line or the environment?
12510 
12511     # Try to remove the string !GREP! from our list.
12512     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!GREP!/}
12513     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12514       # If it failed, the variable was not from the command line. Ignore it,
12515       # but warn the user (except for BASH, which is always set by the calling BASH).
12516       if test "xGREP" != xBASH; then
12517         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of GREP from the environment. Use command line variables instead." >&5
12518 $as_echo "$as_me: WARNING: Ignoring value of GREP from the environment. Use command line variables instead." >&2;}
12519       fi
12520       # Try to locate tool using the code snippet
12521       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
12522 $as_echo_n "checking for grep that handles long lines and -e... " >&6; }
12523 if ${ac_cv_path_GREP+:} false; then :
12524   $as_echo_n "(cached) " >&6
12525 else
12526   if test -z "$GREP"; then
12527   ac_path_GREP_found=false
12528   # Loop through the user's path and test for each of PROGNAME-LIST
12529   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12530 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
12531 do
12532   IFS=$as_save_IFS
12533   test -z "$as_dir" && as_dir=.
12534     for ac_prog in grep ggrep; do
12535     for ac_exec_ext in '' $ac_executable_extensions; do
12536       ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
12537       as_fn_executable_p "$ac_path_GREP" || continue
12538 # Check for GNU ac_path_GREP and select it if it is found.
12539   # Check for GNU $ac_path_GREP
12540 case `"$ac_path_GREP" --version 2>&1` in
12541 *GNU*)
12542   ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
12543 *)
12544   ac_count=0
12545   $as_echo_n 0123456789 >"conftest.in"
12546   while :
12547   do
12548     cat "conftest.in" "conftest.in" >"conftest.tmp"
12549     mv "conftest.tmp" "conftest.in"
12550     cp "conftest.in" "conftest.nl"
12551     $as_echo 'GREP' >> "conftest.nl"
12552     "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
12553     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12554     as_fn_arith $ac_count + 1 && ac_count=$as_val
12555     if test $ac_count -gt ${ac_path_GREP_max-0}; then
12556       # Best one so far, save it but keep looking for a better one
12557       ac_cv_path_GREP="$ac_path_GREP"
12558       ac_path_GREP_max=$ac_count
12559     fi
12560     # 10*(2^10) chars as input seems more than enough
12561     test $ac_count -gt 10 && break
12562   done
12563   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12564 esac
12565 
12566       $ac_path_GREP_found && break 3
12567     done
12568   done
12569   done
12570 IFS=$as_save_IFS
12571   if test -z "$ac_cv_path_GREP"; then
12572     as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
12573   fi
12574 else
12575   ac_cv_path_GREP=$GREP
12576 fi
12577 
12578 fi
12579 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
12580 $as_echo "$ac_cv_path_GREP" >&6; }
12581  GREP="$ac_cv_path_GREP"
12582 
12583 
12584     else
12585       # If it succeeded, then it was overridden by the user. We will use it
12586       # for the tool.
12587 
12588       # First remove it from the list of overridden variables, so we can test
12589       # for unknown variables in the end.
12590       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12591 
12592       # Check if we try to supply an empty value
12593       if test "x$GREP" = x; then
12594         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool GREP= (no value)" >&5
12595 $as_echo "$as_me: Setting user supplied tool GREP= (no value)" >&6;}
12596         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GREP" >&5
12597 $as_echo_n "checking for GREP... " >&6; }
12598         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
12599 $as_echo "disabled" >&6; }
12600       else
12601         # Check if the provided tool contains a complete path.
12602         tool_specified="$GREP"
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 GREP=$tool_basename" >&5
12607 $as_echo "$as_me: Will search for user supplied tool GREP=$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_GREP+:} false; then :
12613   $as_echo_n "(cached) " >&6
12614 else
12615   case $GREP in
12616   [\\/]* | ?:[\\/]*)
12617   ac_cv_path_GREP="$GREP" # 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_GREP="$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 GREP=$ac_cv_path_GREP
12639 if test -n "$GREP"; then
12640   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GREP" >&5
12641 $as_echo "$GREP" >&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$GREP" = 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 GREP=$tool_specified" >&5
12654 $as_echo "$as_me: Will use user supplied tool GREP=$tool_specified" >&6;}
12655           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GREP" >&5
12656 $as_echo_n "checking for GREP... " >&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 GREP=$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   fi
12669 
12670 
12671   if test "x$GREP" = x; then
12672     as_fn_error $? "Could not find required tool for GREP" "$LINENO" 5
12673   fi
12674 
12675 
12676 
12677 
12678   # Publish this variable in the help.
12679 
12680 
12681   if [ -z "${EGREP+x}" ]; then
12682     # The variable is not set by user, try to locate tool using the code snippet
12683     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
12684 $as_echo_n "checking for egrep... " >&6; }
12685 if ${ac_cv_path_EGREP+:} false; then :
12686   $as_echo_n "(cached) " >&6
12687 else
12688   if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
12689    then ac_cv_path_EGREP="$GREP -E"
12690    else
12691      if test -z "$EGREP"; then
12692   ac_path_EGREP_found=false
12693   # Loop through the user's path and test for each of PROGNAME-LIST
12694   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12695 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
12696 do
12697   IFS=$as_save_IFS
12698   test -z "$as_dir" && as_dir=.
12699     for ac_prog in egrep; do
12700     for ac_exec_ext in '' $ac_executable_extensions; do
12701       ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
12702       as_fn_executable_p "$ac_path_EGREP" || continue
12703 # Check for GNU ac_path_EGREP and select it if it is found.
12704   # Check for GNU $ac_path_EGREP
12705 case `"$ac_path_EGREP" --version 2>&1` in
12706 *GNU*)
12707   ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
12708 *)
12709   ac_count=0
12710   $as_echo_n 0123456789 >"conftest.in"
12711   while :
12712   do
12713     cat "conftest.in" "conftest.in" >"conftest.tmp"
12714     mv "conftest.tmp" "conftest.in"
12715     cp "conftest.in" "conftest.nl"
12716     $as_echo 'EGREP' >> "conftest.nl"
12717     "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
12718     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12719     as_fn_arith $ac_count + 1 && ac_count=$as_val
12720     if test $ac_count -gt ${ac_path_EGREP_max-0}; then
12721       # Best one so far, save it but keep looking for a better one
12722       ac_cv_path_EGREP="$ac_path_EGREP"
12723       ac_path_EGREP_max=$ac_count
12724     fi
12725     # 10*(2^10) chars as input seems more than enough
12726     test $ac_count -gt 10 && break
12727   done
12728   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12729 esac
12730 
12731       $ac_path_EGREP_found && break 3
12732     done
12733   done
12734   done
12735 IFS=$as_save_IFS
12736   if test -z "$ac_cv_path_EGREP"; then
12737     as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
12738   fi
12739 else
12740   ac_cv_path_EGREP=$EGREP
12741 fi
12742 
12743    fi
12744 fi
12745 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
12746 $as_echo "$ac_cv_path_EGREP" >&6; }
12747  EGREP="$ac_cv_path_EGREP"
12748 
12749 
12750   else
12751     # The variable is set, but is it from the command line or the environment?
12752 
12753     # Try to remove the string !EGREP! from our list.
12754     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!EGREP!/}
12755     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12756       # If it failed, the variable was not from the command line. Ignore it,
12757       # but warn the user (except for BASH, which is always set by the calling BASH).
12758       if test "xEGREP" != xBASH; then
12759         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of EGREP from the environment. Use command line variables instead." >&5
12760 $as_echo "$as_me: WARNING: Ignoring value of EGREP from the environment. Use command line variables instead." >&2;}
12761       fi
12762       # Try to locate tool using the code snippet
12763       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
12764 $as_echo_n "checking for egrep... " >&6; }
12765 if ${ac_cv_path_EGREP+:} false; then :
12766   $as_echo_n "(cached) " >&6
12767 else
12768   if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
12769    then ac_cv_path_EGREP="$GREP -E"
12770    else
12771      if test -z "$EGREP"; then
12772   ac_path_EGREP_found=false
12773   # Loop through the user's path and test for each of PROGNAME-LIST
12774   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12775 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
12776 do
12777   IFS=$as_save_IFS
12778   test -z "$as_dir" && as_dir=.
12779     for ac_prog in egrep; do
12780     for ac_exec_ext in '' $ac_executable_extensions; do
12781       ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
12782       as_fn_executable_p "$ac_path_EGREP" || continue
12783 # Check for GNU ac_path_EGREP and select it if it is found.
12784   # Check for GNU $ac_path_EGREP
12785 case `"$ac_path_EGREP" --version 2>&1` in
12786 *GNU*)
12787   ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
12788 *)
12789   ac_count=0
12790   $as_echo_n 0123456789 >"conftest.in"
12791   while :
12792   do
12793     cat "conftest.in" "conftest.in" >"conftest.tmp"
12794     mv "conftest.tmp" "conftest.in"
12795     cp "conftest.in" "conftest.nl"
12796     $as_echo 'EGREP' >> "conftest.nl"
12797     "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
12798     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12799     as_fn_arith $ac_count + 1 && ac_count=$as_val
12800     if test $ac_count -gt ${ac_path_EGREP_max-0}; then
12801       # Best one so far, save it but keep looking for a better one
12802       ac_cv_path_EGREP="$ac_path_EGREP"
12803       ac_path_EGREP_max=$ac_count
12804     fi
12805     # 10*(2^10) chars as input seems more than enough
12806     test $ac_count -gt 10 && break
12807   done
12808   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12809 esac
12810 
12811       $ac_path_EGREP_found && break 3
12812     done
12813   done
12814   done
12815 IFS=$as_save_IFS
12816   if test -z "$ac_cv_path_EGREP"; then
12817     as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
12818   fi
12819 else
12820   ac_cv_path_EGREP=$EGREP
12821 fi
12822 
12823    fi
12824 fi
12825 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
12826 $as_echo "$ac_cv_path_EGREP" >&6; }
12827  EGREP="$ac_cv_path_EGREP"
12828 
12829 
12830     else
12831       # If it succeeded, then it was overridden by the user. We will use it
12832       # for the tool.
12833 
12834       # First remove it from the list of overridden variables, so we can test
12835       # for unknown variables in the end.
12836       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12837 
12838       # Check if we try to supply an empty value
12839       if test "x$EGREP" = x; then
12840         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool EGREP= (no value)" >&5
12841 $as_echo "$as_me: Setting user supplied tool EGREP= (no value)" >&6;}
12842         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EGREP" >&5
12843 $as_echo_n "checking for EGREP... " >&6; }
12844         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
12845 $as_echo "disabled" >&6; }
12846       else
12847         # Check if the provided tool contains a complete path.
12848         tool_specified="$EGREP"
12849         tool_basename="${tool_specified##*/}"
12850         if test "x$tool_basename" = "x$tool_specified"; then
12851           # A command without a complete path is provided, search $PATH.
12852           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool EGREP=$tool_basename" >&5
12853 $as_echo "$as_me: Will search for user supplied tool EGREP=$tool_basename" >&6;}
12854           # Extract the first word of "$tool_basename", so it can be a program name with args.
12855 set dummy $tool_basename; ac_word=$2
12856 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12857 $as_echo_n "checking for $ac_word... " >&6; }
12858 if ${ac_cv_path_EGREP+:} false; then :
12859   $as_echo_n "(cached) " >&6
12860 else
12861   case $EGREP in
12862   [\\/]* | ?:[\\/]*)
12863   ac_cv_path_EGREP="$EGREP" # Let the user override the test with a path.
12864   ;;
12865   *)
12866   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12867 for as_dir in $PATH
12868 do
12869   IFS=$as_save_IFS
12870   test -z "$as_dir" && as_dir=.
12871     for ac_exec_ext in '' $ac_executable_extensions; do
12872   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12873     ac_cv_path_EGREP="$as_dir/$ac_word$ac_exec_ext"
12874     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12875     break 2
12876   fi
12877 done
12878   done
12879 IFS=$as_save_IFS
12880 
12881   ;;
12882 esac
12883 fi
12884 EGREP=$ac_cv_path_EGREP
12885 if test -n "$EGREP"; then
12886   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EGREP" >&5
12887 $as_echo "$EGREP" >&6; }
12888 else
12889   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12890 $as_echo "no" >&6; }
12891 fi
12892 
12893 
12894           if test "x$EGREP" = x; then
12895             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12896           fi
12897         else
12898           # Otherwise we believe it is a complete path. Use it as it is.
12899           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool EGREP=$tool_specified" >&5
12900 $as_echo "$as_me: Will use user supplied tool EGREP=$tool_specified" >&6;}
12901           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EGREP" >&5
12902 $as_echo_n "checking for EGREP... " >&6; }
12903           if test ! -x "$tool_specified"; then
12904             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12905 $as_echo "not found" >&6; }
12906             as_fn_error $? "User supplied tool EGREP=$tool_specified does not exist or is not executable" "$LINENO" 5
12907           fi
12908           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12909 $as_echo "$tool_specified" >&6; }
12910         fi
12911       fi
12912     fi
12913 
12914   fi
12915 
12916 
12917   if test "x$EGREP" = x; then
12918     as_fn_error $? "Could not find required tool for EGREP" "$LINENO" 5
12919   fi
12920 
12921 
12922 
12923 
12924   # Publish this variable in the help.
12925 
12926 
12927   if [ -z "${FGREP+x}" ]; then
12928     # The variable is not set by user, try to locate tool using the code snippet
12929     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
12930 $as_echo_n "checking for fgrep... " >&6; }
12931 if ${ac_cv_path_FGREP+:} false; then :
12932   $as_echo_n "(cached) " >&6
12933 else
12934   if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
12935    then ac_cv_path_FGREP="$GREP -F"
12936    else
12937      if test -z "$FGREP"; then
12938   ac_path_FGREP_found=false
12939   # Loop through the user's path and test for each of PROGNAME-LIST
12940   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12941 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
12942 do
12943   IFS=$as_save_IFS
12944   test -z "$as_dir" && as_dir=.
12945     for ac_prog in fgrep; do
12946     for ac_exec_ext in '' $ac_executable_extensions; do
12947       ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
12948       as_fn_executable_p "$ac_path_FGREP" || continue
12949 # Check for GNU ac_path_FGREP and select it if it is found.
12950   # Check for GNU $ac_path_FGREP
12951 case `"$ac_path_FGREP" --version 2>&1` in
12952 *GNU*)
12953   ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
12954 *)
12955   ac_count=0
12956   $as_echo_n 0123456789 >"conftest.in"
12957   while :
12958   do
12959     cat "conftest.in" "conftest.in" >"conftest.tmp"
12960     mv "conftest.tmp" "conftest.in"
12961     cp "conftest.in" "conftest.nl"
12962     $as_echo 'FGREP' >> "conftest.nl"
12963     "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
12964     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12965     as_fn_arith $ac_count + 1 && ac_count=$as_val
12966     if test $ac_count -gt ${ac_path_FGREP_max-0}; then
12967       # Best one so far, save it but keep looking for a better one
12968       ac_cv_path_FGREP="$ac_path_FGREP"
12969       ac_path_FGREP_max=$ac_count
12970     fi
12971     # 10*(2^10) chars as input seems more than enough
12972     test $ac_count -gt 10 && break
12973   done
12974   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12975 esac
12976 
12977       $ac_path_FGREP_found && break 3
12978     done
12979   done
12980   done
12981 IFS=$as_save_IFS
12982   if test -z "$ac_cv_path_FGREP"; then
12983     as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
12984   fi
12985 else
12986   ac_cv_path_FGREP=$FGREP
12987 fi
12988 
12989    fi
12990 fi
12991 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
12992 $as_echo "$ac_cv_path_FGREP" >&6; }
12993  FGREP="$ac_cv_path_FGREP"
12994 
12995 
12996   else
12997     # The variable is set, but is it from the command line or the environment?
12998 
12999     # Try to remove the string !FGREP! from our list.
13000     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FGREP!/}
13001     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
13002       # If it failed, the variable was not from the command line. Ignore it,
13003       # but warn the user (except for BASH, which is always set by the calling BASH).
13004       if test "xFGREP" != xBASH; then
13005         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FGREP from the environment. Use command line variables instead." >&5
13006 $as_echo "$as_me: WARNING: Ignoring value of FGREP from the environment. Use command line variables instead." >&2;}
13007       fi
13008       # Try to locate tool using the code snippet
13009       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
13010 $as_echo_n "checking for fgrep... " >&6; }
13011 if ${ac_cv_path_FGREP+:} false; then :
13012   $as_echo_n "(cached) " >&6
13013 else
13014   if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
13015    then ac_cv_path_FGREP="$GREP -F"
13016    else
13017      if test -z "$FGREP"; then
13018   ac_path_FGREP_found=false
13019   # Loop through the user's path and test for each of PROGNAME-LIST
13020   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13021 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
13022 do
13023   IFS=$as_save_IFS
13024   test -z "$as_dir" && as_dir=.
13025     for ac_prog in fgrep; do
13026     for ac_exec_ext in '' $ac_executable_extensions; do
13027       ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
13028       as_fn_executable_p "$ac_path_FGREP" || continue
13029 # Check for GNU ac_path_FGREP and select it if it is found.
13030   # Check for GNU $ac_path_FGREP
13031 case `"$ac_path_FGREP" --version 2>&1` in
13032 *GNU*)
13033   ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
13034 *)
13035   ac_count=0
13036   $as_echo_n 0123456789 >"conftest.in"
13037   while :
13038   do
13039     cat "conftest.in" "conftest.in" >"conftest.tmp"
13040     mv "conftest.tmp" "conftest.in"
13041     cp "conftest.in" "conftest.nl"
13042     $as_echo 'FGREP' >> "conftest.nl"
13043     "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
13044     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
13045     as_fn_arith $ac_count + 1 && ac_count=$as_val
13046     if test $ac_count -gt ${ac_path_FGREP_max-0}; then
13047       # Best one so far, save it but keep looking for a better one
13048       ac_cv_path_FGREP="$ac_path_FGREP"
13049       ac_path_FGREP_max=$ac_count
13050     fi
13051     # 10*(2^10) chars as input seems more than enough
13052     test $ac_count -gt 10 && break
13053   done
13054   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
13055 esac
13056 
13057       $ac_path_FGREP_found && break 3
13058     done
13059   done
13060   done
13061 IFS=$as_save_IFS
13062   if test -z "$ac_cv_path_FGREP"; then
13063     as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
13064   fi
13065 else
13066   ac_cv_path_FGREP=$FGREP
13067 fi
13068 
13069    fi
13070 fi
13071 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
13072 $as_echo "$ac_cv_path_FGREP" >&6; }
13073  FGREP="$ac_cv_path_FGREP"
13074 
13075 
13076     else
13077       # If it succeeded, then it was overridden by the user. We will use it
13078       # for the tool.
13079 
13080       # First remove it from the list of overridden variables, so we can test
13081       # for unknown variables in the end.
13082       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13083 
13084       # Check if we try to supply an empty value
13085       if test "x$FGREP" = x; then
13086         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool FGREP= (no value)" >&5
13087 $as_echo "$as_me: Setting user supplied tool FGREP= (no value)" >&6;}
13088         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FGREP" >&5
13089 $as_echo_n "checking for FGREP... " >&6; }
13090         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
13091 $as_echo "disabled" >&6; }
13092       else
13093         # Check if the provided tool contains a complete path.
13094         tool_specified="$FGREP"
13095         tool_basename="${tool_specified##*/}"
13096         if test "x$tool_basename" = "x$tool_specified"; then
13097           # A command without a complete path is provided, search $PATH.
13098           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FGREP=$tool_basename" >&5
13099 $as_echo "$as_me: Will search for user supplied tool FGREP=$tool_basename" >&6;}
13100           # Extract the first word of "$tool_basename", so it can be a program name with args.
13101 set dummy $tool_basename; ac_word=$2
13102 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13103 $as_echo_n "checking for $ac_word... " >&6; }
13104 if ${ac_cv_path_FGREP+:} false; then :
13105   $as_echo_n "(cached) " >&6
13106 else
13107   case $FGREP in
13108   [\\/]* | ?:[\\/]*)
13109   ac_cv_path_FGREP="$FGREP" # Let the user override the test with a path.
13110   ;;
13111   *)
13112   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13113 for as_dir in $PATH
13114 do
13115   IFS=$as_save_IFS
13116   test -z "$as_dir" && as_dir=.
13117     for ac_exec_ext in '' $ac_executable_extensions; do
13118   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13119     ac_cv_path_FGREP="$as_dir/$ac_word$ac_exec_ext"
13120     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13121     break 2
13122   fi
13123 done
13124   done
13125 IFS=$as_save_IFS
13126 
13127   ;;
13128 esac
13129 fi
13130 FGREP=$ac_cv_path_FGREP
13131 if test -n "$FGREP"; then
13132   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FGREP" >&5
13133 $as_echo "$FGREP" >&6; }
13134 else
13135   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13136 $as_echo "no" >&6; }
13137 fi
13138 
13139 
13140           if test "x$FGREP" = x; then
13141             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13142           fi
13143         else
13144           # Otherwise we believe it is a complete path. Use it as it is.
13145           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FGREP=$tool_specified" >&5
13146 $as_echo "$as_me: Will use user supplied tool FGREP=$tool_specified" >&6;}
13147           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FGREP" >&5
13148 $as_echo_n "checking for FGREP... " >&6; }
13149           if test ! -x "$tool_specified"; then
13150             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13151 $as_echo "not found" >&6; }
13152             as_fn_error $? "User supplied tool FGREP=$tool_specified does not exist or is not executable" "$LINENO" 5
13153           fi
13154           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13155 $as_echo "$tool_specified" >&6; }
13156         fi
13157       fi
13158     fi
13159 
13160   fi
13161 
13162 
13163   if test "x$FGREP" = x; then
13164     as_fn_error $? "Could not find required tool for FGREP" "$LINENO" 5
13165   fi
13166 
13167 
13168 
13169 
13170   # Publish this variable in the help.
13171 
13172 
13173   if [ -z "${SED+x}" ]; then
13174     # The variable is not set by user, try to locate tool using the code snippet
13175     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
13176 $as_echo_n "checking for a sed that does not truncate output... " >&6; }
13177 if ${ac_cv_path_SED+:} false; then :
13178   $as_echo_n "(cached) " >&6
13179 else
13180             ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
13181      for ac_i in 1 2 3 4 5 6 7; do
13182        ac_script="$ac_script$as_nl$ac_script"
13183      done
13184      echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
13185      { ac_script=; unset ac_script;}
13186      if test -z "$SED"; then
13187   ac_path_SED_found=false
13188   # Loop through the user's path and test for each of PROGNAME-LIST
13189   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13190 for as_dir in $PATH
13191 do
13192   IFS=$as_save_IFS
13193   test -z "$as_dir" && as_dir=.
13194     for ac_prog in sed gsed; do
13195     for ac_exec_ext in '' $ac_executable_extensions; do
13196       ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
13197       as_fn_executable_p "$ac_path_SED" || continue
13198 # Check for GNU ac_path_SED and select it if it is found.
13199   # Check for GNU $ac_path_SED
13200 case `"$ac_path_SED" --version 2>&1` in
13201 *GNU*)
13202   ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
13203 *)
13204   ac_count=0
13205   $as_echo_n 0123456789 >"conftest.in"
13206   while :
13207   do
13208     cat "conftest.in" "conftest.in" >"conftest.tmp"
13209     mv "conftest.tmp" "conftest.in"
13210     cp "conftest.in" "conftest.nl"
13211     $as_echo '' >> "conftest.nl"
13212     "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
13213     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
13214     as_fn_arith $ac_count + 1 && ac_count=$as_val
13215     if test $ac_count -gt ${ac_path_SED_max-0}; then
13216       # Best one so far, save it but keep looking for a better one
13217       ac_cv_path_SED="$ac_path_SED"
13218       ac_path_SED_max=$ac_count
13219     fi
13220     # 10*(2^10) chars as input seems more than enough
13221     test $ac_count -gt 10 && break
13222   done
13223   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
13224 esac
13225 
13226       $ac_path_SED_found && break 3
13227     done
13228   done
13229   done
13230 IFS=$as_save_IFS
13231   if test -z "$ac_cv_path_SED"; then
13232     as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
13233   fi
13234 else
13235   ac_cv_path_SED=$SED
13236 fi
13237 
13238 fi
13239 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
13240 $as_echo "$ac_cv_path_SED" >&6; }
13241  SED="$ac_cv_path_SED"
13242   rm -f conftest.sed
13243 
13244   else
13245     # The variable is set, but is it from the command line or the environment?
13246 
13247     # Try to remove the string !SED! from our list.
13248     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SED!/}
13249     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
13250       # If it failed, the variable was not from the command line. Ignore it,
13251       # but warn the user (except for BASH, which is always set by the calling BASH).
13252       if test "xSED" != xBASH; then
13253         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SED from the environment. Use command line variables instead." >&5
13254 $as_echo "$as_me: WARNING: Ignoring value of SED from the environment. Use command line variables instead." >&2;}
13255       fi
13256       # Try to locate tool using the code snippet
13257       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
13258 $as_echo_n "checking for a sed that does not truncate output... " >&6; }
13259 if ${ac_cv_path_SED+:} false; then :
13260   $as_echo_n "(cached) " >&6
13261 else
13262             ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
13263      for ac_i in 1 2 3 4 5 6 7; do
13264        ac_script="$ac_script$as_nl$ac_script"
13265      done
13266      echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
13267      { ac_script=; unset ac_script;}
13268      if test -z "$SED"; then
13269   ac_path_SED_found=false
13270   # Loop through the user's path and test for each of PROGNAME-LIST
13271   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13272 for as_dir in $PATH
13273 do
13274   IFS=$as_save_IFS
13275   test -z "$as_dir" && as_dir=.
13276     for ac_prog in sed gsed; do
13277     for ac_exec_ext in '' $ac_executable_extensions; do
13278       ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
13279       as_fn_executable_p "$ac_path_SED" || continue
13280 # Check for GNU ac_path_SED and select it if it is found.
13281   # Check for GNU $ac_path_SED
13282 case `"$ac_path_SED" --version 2>&1` in
13283 *GNU*)
13284   ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
13285 *)
13286   ac_count=0
13287   $as_echo_n 0123456789 >"conftest.in"
13288   while :
13289   do
13290     cat "conftest.in" "conftest.in" >"conftest.tmp"
13291     mv "conftest.tmp" "conftest.in"
13292     cp "conftest.in" "conftest.nl"
13293     $as_echo '' >> "conftest.nl"
13294     "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
13295     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
13296     as_fn_arith $ac_count + 1 && ac_count=$as_val
13297     if test $ac_count -gt ${ac_path_SED_max-0}; then
13298       # Best one so far, save it but keep looking for a better one
13299       ac_cv_path_SED="$ac_path_SED"
13300       ac_path_SED_max=$ac_count
13301     fi
13302     # 10*(2^10) chars as input seems more than enough
13303     test $ac_count -gt 10 && break
13304   done
13305   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
13306 esac
13307 
13308       $ac_path_SED_found && break 3
13309     done
13310   done
13311   done
13312 IFS=$as_save_IFS
13313   if test -z "$ac_cv_path_SED"; then
13314     as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
13315   fi
13316 else
13317   ac_cv_path_SED=$SED
13318 fi
13319 
13320 fi
13321 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
13322 $as_echo "$ac_cv_path_SED" >&6; }
13323  SED="$ac_cv_path_SED"
13324   rm -f conftest.sed
13325 
13326     else
13327       # If it succeeded, then it was overridden by the user. We will use it
13328       # for the tool.
13329 
13330       # First remove it from the list of overridden variables, so we can test
13331       # for unknown variables in the end.
13332       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13333 
13334       # Check if we try to supply an empty value
13335       if test "x$SED" = x; then
13336         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool SED= (no value)" >&5
13337 $as_echo "$as_me: Setting user supplied tool SED= (no value)" >&6;}
13338         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SED" >&5
13339 $as_echo_n "checking for SED... " >&6; }
13340         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
13341 $as_echo "disabled" >&6; }
13342       else
13343         # Check if the provided tool contains a complete path.
13344         tool_specified="$SED"
13345         tool_basename="${tool_specified##*/}"
13346         if test "x$tool_basename" = "x$tool_specified"; then
13347           # A command without a complete path is provided, search $PATH.
13348           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SED=$tool_basename" >&5
13349 $as_echo "$as_me: Will search for user supplied tool SED=$tool_basename" >&6;}
13350           # Extract the first word of "$tool_basename", so it can be a program name with args.
13351 set dummy $tool_basename; ac_word=$2
13352 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13353 $as_echo_n "checking for $ac_word... " >&6; }
13354 if ${ac_cv_path_SED+:} false; then :
13355   $as_echo_n "(cached) " >&6
13356 else
13357   case $SED in
13358   [\\/]* | ?:[\\/]*)
13359   ac_cv_path_SED="$SED" # Let the user override the test with a path.
13360   ;;
13361   *)
13362   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13363 for as_dir in $PATH
13364 do
13365   IFS=$as_save_IFS
13366   test -z "$as_dir" && as_dir=.
13367     for ac_exec_ext in '' $ac_executable_extensions; do
13368   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13369     ac_cv_path_SED="$as_dir/$ac_word$ac_exec_ext"
13370     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13371     break 2
13372   fi
13373 done
13374   done
13375 IFS=$as_save_IFS
13376 
13377   ;;
13378 esac
13379 fi
13380 SED=$ac_cv_path_SED
13381 if test -n "$SED"; then
13382   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SED" >&5
13383 $as_echo "$SED" >&6; }
13384 else
13385   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13386 $as_echo "no" >&6; }
13387 fi
13388 
13389 
13390           if test "x$SED" = x; then
13391             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13392           fi
13393         else
13394           # Otherwise we believe it is a complete path. Use it as it is.
13395           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SED=$tool_specified" >&5
13396 $as_echo "$as_me: Will use user supplied tool SED=$tool_specified" >&6;}
13397           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SED" >&5
13398 $as_echo_n "checking for SED... " >&6; }
13399           if test ! -x "$tool_specified"; then
13400             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13401 $as_echo "not found" >&6; }
13402             as_fn_error $? "User supplied tool SED=$tool_specified does not exist or is not executable" "$LINENO" 5
13403           fi
13404           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13405 $as_echo "$tool_specified" >&6; }
13406         fi
13407       fi
13408     fi
13409 
13410   fi
13411 
13412 
13413   if test "x$SED" = x; then
13414     as_fn_error $? "Could not find required tool for SED" "$LINENO" 5
13415   fi
13416 
13417 
13418 
13419   # Always force rm.
13420   RM="$RM -f"
13421 
13422   # pwd behaves differently on various platforms and some don't support the -L flag.
13423   # Always use the bash builtin pwd to get uniform behavior.
13424   THEPWDCMD=pwd
13425 
13426   # These are not required on all platforms
13427 
13428 
13429   # Publish this variable in the help.
13430 
13431 
13432   if [ -z "${CYGPATH+x}" ]; then
13433     # The variable is not set by user, try to locate tool using the code snippet
13434     for ac_prog in cygpath
13435 do
13436   # Extract the first word of "$ac_prog", so it can be a program name with args.
13437 set dummy $ac_prog; ac_word=$2
13438 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13439 $as_echo_n "checking for $ac_word... " >&6; }
13440 if ${ac_cv_path_CYGPATH+:} false; then :
13441   $as_echo_n "(cached) " >&6
13442 else
13443   case $CYGPATH in
13444   [\\/]* | ?:[\\/]*)
13445   ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
13446   ;;
13447   *)
13448   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13449 for as_dir in $PATH
13450 do
13451   IFS=$as_save_IFS
13452   test -z "$as_dir" && as_dir=.
13453     for ac_exec_ext in '' $ac_executable_extensions; do
13454   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13455     ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
13456     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13457     break 2
13458   fi
13459 done
13460   done
13461 IFS=$as_save_IFS
13462 
13463   ;;
13464 esac
13465 fi
13466 CYGPATH=$ac_cv_path_CYGPATH
13467 if test -n "$CYGPATH"; then
13468   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
13469 $as_echo "$CYGPATH" >&6; }
13470 else
13471   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13472 $as_echo "no" >&6; }
13473 fi
13474 
13475 
13476   test -n "$CYGPATH" && break
13477 done
13478 
13479   else
13480     # The variable is set, but is it from the command line or the environment?
13481 
13482     # Try to remove the string !CYGPATH! from our list.
13483     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CYGPATH!/}
13484     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
13485       # If it failed, the variable was not from the command line. Ignore it,
13486       # but warn the user (except for BASH, which is always set by the calling BASH).
13487       if test "xCYGPATH" != xBASH; then
13488         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CYGPATH from the environment. Use command line variables instead." >&5
13489 $as_echo "$as_me: WARNING: Ignoring value of CYGPATH from the environment. Use command line variables instead." >&2;}
13490       fi
13491       # Try to locate tool using the code snippet
13492       for ac_prog in cygpath
13493 do
13494   # Extract the first word of "$ac_prog", so it can be a program name with args.
13495 set dummy $ac_prog; ac_word=$2
13496 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13497 $as_echo_n "checking for $ac_word... " >&6; }
13498 if ${ac_cv_path_CYGPATH+:} false; then :
13499   $as_echo_n "(cached) " >&6
13500 else
13501   case $CYGPATH in
13502   [\\/]* | ?:[\\/]*)
13503   ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
13504   ;;
13505   *)
13506   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13507 for as_dir in $PATH
13508 do
13509   IFS=$as_save_IFS
13510   test -z "$as_dir" && as_dir=.
13511     for ac_exec_ext in '' $ac_executable_extensions; do
13512   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13513     ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
13514     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13515     break 2
13516   fi
13517 done
13518   done
13519 IFS=$as_save_IFS
13520 
13521   ;;
13522 esac
13523 fi
13524 CYGPATH=$ac_cv_path_CYGPATH
13525 if test -n "$CYGPATH"; then
13526   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
13527 $as_echo "$CYGPATH" >&6; }
13528 else
13529   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13530 $as_echo "no" >&6; }
13531 fi
13532 
13533 
13534   test -n "$CYGPATH" && break
13535 done
13536 
13537     else
13538       # If it succeeded, then it was overridden by the user. We will use it
13539       # for the tool.
13540 
13541       # First remove it from the list of overridden variables, so we can test
13542       # for unknown variables in the end.
13543       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13544 
13545       # Check if we try to supply an empty value
13546       if test "x$CYGPATH" = x; then
13547         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CYGPATH= (no value)" >&5
13548 $as_echo "$as_me: Setting user supplied tool CYGPATH= (no value)" >&6;}
13549         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CYGPATH" >&5
13550 $as_echo_n "checking for CYGPATH... " >&6; }
13551         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
13552 $as_echo "disabled" >&6; }
13553       else
13554         # Check if the provided tool contains a complete path.
13555         tool_specified="$CYGPATH"
13556         tool_basename="${tool_specified##*/}"
13557         if test "x$tool_basename" = "x$tool_specified"; then
13558           # A command without a complete path is provided, search $PATH.
13559           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CYGPATH=$tool_basename" >&5
13560 $as_echo "$as_me: Will search for user supplied tool CYGPATH=$tool_basename" >&6;}
13561           # Extract the first word of "$tool_basename", so it can be a program name with args.
13562 set dummy $tool_basename; ac_word=$2
13563 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13564 $as_echo_n "checking for $ac_word... " >&6; }
13565 if ${ac_cv_path_CYGPATH+:} false; then :
13566   $as_echo_n "(cached) " >&6
13567 else
13568   case $CYGPATH in
13569   [\\/]* | ?:[\\/]*)
13570   ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
13571   ;;
13572   *)
13573   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13574 for as_dir in $PATH
13575 do
13576   IFS=$as_save_IFS
13577   test -z "$as_dir" && as_dir=.
13578     for ac_exec_ext in '' $ac_executable_extensions; do
13579   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13580     ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
13581     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13582     break 2
13583   fi
13584 done
13585   done
13586 IFS=$as_save_IFS
13587 
13588   ;;
13589 esac
13590 fi
13591 CYGPATH=$ac_cv_path_CYGPATH
13592 if test -n "$CYGPATH"; then
13593   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
13594 $as_echo "$CYGPATH" >&6; }
13595 else
13596   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13597 $as_echo "no" >&6; }
13598 fi
13599 
13600 
13601           if test "x$CYGPATH" = x; then
13602             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13603           fi
13604         else
13605           # Otherwise we believe it is a complete path. Use it as it is.
13606           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CYGPATH=$tool_specified" >&5
13607 $as_echo "$as_me: Will use user supplied tool CYGPATH=$tool_specified" >&6;}
13608           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CYGPATH" >&5
13609 $as_echo_n "checking for CYGPATH... " >&6; }
13610           if test ! -x "$tool_specified"; then
13611             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13612 $as_echo "not found" >&6; }
13613             as_fn_error $? "User supplied tool CYGPATH=$tool_specified does not exist or is not executable" "$LINENO" 5
13614           fi
13615           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13616 $as_echo "$tool_specified" >&6; }
13617         fi
13618       fi
13619     fi
13620 
13621   fi
13622 
13623 
13624 
13625 
13626   # Publish this variable in the help.
13627 
13628 
13629   if [ -z "${READLINK+x}" ]; then
13630     # The variable is not set by user, try to locate tool using the code snippet
13631     for ac_prog in greadlink readlink
13632 do
13633   # Extract the first word of "$ac_prog", so it can be a program name with args.
13634 set dummy $ac_prog; ac_word=$2
13635 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13636 $as_echo_n "checking for $ac_word... " >&6; }
13637 if ${ac_cv_path_READLINK+:} false; then :
13638   $as_echo_n "(cached) " >&6
13639 else
13640   case $READLINK in
13641   [\\/]* | ?:[\\/]*)
13642   ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
13643   ;;
13644   *)
13645   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13646 for as_dir in $PATH
13647 do
13648   IFS=$as_save_IFS
13649   test -z "$as_dir" && as_dir=.
13650     for ac_exec_ext in '' $ac_executable_extensions; do
13651   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13652     ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
13653     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13654     break 2
13655   fi
13656 done
13657   done
13658 IFS=$as_save_IFS
13659 
13660   ;;
13661 esac
13662 fi
13663 READLINK=$ac_cv_path_READLINK
13664 if test -n "$READLINK"; then
13665   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
13666 $as_echo "$READLINK" >&6; }
13667 else
13668   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13669 $as_echo "no" >&6; }
13670 fi
13671 
13672 
13673   test -n "$READLINK" && break
13674 done
13675 
13676   else
13677     # The variable is set, but is it from the command line or the environment?
13678 
13679     # Try to remove the string !READLINK! from our list.
13680     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!READLINK!/}
13681     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
13682       # If it failed, the variable was not from the command line. Ignore it,
13683       # but warn the user (except for BASH, which is always set by the calling BASH).
13684       if test "xREADLINK" != xBASH; then
13685         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of READLINK from the environment. Use command line variables instead." >&5
13686 $as_echo "$as_me: WARNING: Ignoring value of READLINK from the environment. Use command line variables instead." >&2;}
13687       fi
13688       # Try to locate tool using the code snippet
13689       for ac_prog in greadlink readlink
13690 do
13691   # Extract the first word of "$ac_prog", so it can be a program name with args.
13692 set dummy $ac_prog; ac_word=$2
13693 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13694 $as_echo_n "checking for $ac_word... " >&6; }
13695 if ${ac_cv_path_READLINK+:} false; then :
13696   $as_echo_n "(cached) " >&6
13697 else
13698   case $READLINK in
13699   [\\/]* | ?:[\\/]*)
13700   ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
13701   ;;
13702   *)
13703   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13704 for as_dir in $PATH
13705 do
13706   IFS=$as_save_IFS
13707   test -z "$as_dir" && as_dir=.
13708     for ac_exec_ext in '' $ac_executable_extensions; do
13709   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13710     ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
13711     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13712     break 2
13713   fi
13714 done
13715   done
13716 IFS=$as_save_IFS
13717 
13718   ;;
13719 esac
13720 fi
13721 READLINK=$ac_cv_path_READLINK
13722 if test -n "$READLINK"; then
13723   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
13724 $as_echo "$READLINK" >&6; }
13725 else
13726   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13727 $as_echo "no" >&6; }
13728 fi
13729 
13730 
13731   test -n "$READLINK" && break
13732 done
13733 
13734     else
13735       # If it succeeded, then it was overridden by the user. We will use it
13736       # for the tool.
13737 
13738       # First remove it from the list of overridden variables, so we can test
13739       # for unknown variables in the end.
13740       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13741 
13742       # Check if we try to supply an empty value
13743       if test "x$READLINK" = x; then
13744         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool READLINK= (no value)" >&5
13745 $as_echo "$as_me: Setting user supplied tool READLINK= (no value)" >&6;}
13746         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READLINK" >&5
13747 $as_echo_n "checking for READLINK... " >&6; }
13748         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
13749 $as_echo "disabled" >&6; }
13750       else
13751         # Check if the provided tool contains a complete path.
13752         tool_specified="$READLINK"
13753         tool_basename="${tool_specified##*/}"
13754         if test "x$tool_basename" = "x$tool_specified"; then
13755           # A command without a complete path is provided, search $PATH.
13756           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool READLINK=$tool_basename" >&5
13757 $as_echo "$as_me: Will search for user supplied tool READLINK=$tool_basename" >&6;}
13758           # Extract the first word of "$tool_basename", so it can be a program name with args.
13759 set dummy $tool_basename; ac_word=$2
13760 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13761 $as_echo_n "checking for $ac_word... " >&6; }
13762 if ${ac_cv_path_READLINK+:} false; then :
13763   $as_echo_n "(cached) " >&6
13764 else
13765   case $READLINK in
13766   [\\/]* | ?:[\\/]*)
13767   ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
13768   ;;
13769   *)
13770   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13771 for as_dir in $PATH
13772 do
13773   IFS=$as_save_IFS
13774   test -z "$as_dir" && as_dir=.
13775     for ac_exec_ext in '' $ac_executable_extensions; do
13776   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13777     ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
13778     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13779     break 2
13780   fi
13781 done
13782   done
13783 IFS=$as_save_IFS
13784 
13785   ;;
13786 esac
13787 fi
13788 READLINK=$ac_cv_path_READLINK
13789 if test -n "$READLINK"; then
13790   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
13791 $as_echo "$READLINK" >&6; }
13792 else
13793   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13794 $as_echo "no" >&6; }
13795 fi
13796 
13797 
13798           if test "x$READLINK" = x; then
13799             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13800           fi
13801         else
13802           # Otherwise we believe it is a complete path. Use it as it is.
13803           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool READLINK=$tool_specified" >&5
13804 $as_echo "$as_me: Will use user supplied tool READLINK=$tool_specified" >&6;}
13805           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READLINK" >&5
13806 $as_echo_n "checking for READLINK... " >&6; }
13807           if test ! -x "$tool_specified"; then
13808             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13809 $as_echo "not found" >&6; }
13810             as_fn_error $? "User supplied tool READLINK=$tool_specified does not exist or is not executable" "$LINENO" 5
13811           fi
13812           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13813 $as_echo "$tool_specified" >&6; }
13814         fi
13815       fi
13816     fi
13817 
13818   fi
13819 
13820 
13821 
13822 
13823   # Publish this variable in the help.
13824 
13825 
13826   if [ -z "${DF+x}" ]; then
13827     # The variable is not set by user, try to locate tool using the code snippet
13828     for ac_prog in df
13829 do
13830   # Extract the first word of "$ac_prog", so it can be a program name with args.
13831 set dummy $ac_prog; ac_word=$2
13832 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13833 $as_echo_n "checking for $ac_word... " >&6; }
13834 if ${ac_cv_path_DF+:} false; then :
13835   $as_echo_n "(cached) " >&6
13836 else
13837   case $DF in
13838   [\\/]* | ?:[\\/]*)
13839   ac_cv_path_DF="$DF" # Let the user override the test with a path.
13840   ;;
13841   *)
13842   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13843 for as_dir in $PATH
13844 do
13845   IFS=$as_save_IFS
13846   test -z "$as_dir" && as_dir=.
13847     for ac_exec_ext in '' $ac_executable_extensions; do
13848   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13849     ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
13850     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13851     break 2
13852   fi
13853 done
13854   done
13855 IFS=$as_save_IFS
13856 
13857   ;;
13858 esac
13859 fi
13860 DF=$ac_cv_path_DF
13861 if test -n "$DF"; then
13862   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
13863 $as_echo "$DF" >&6; }
13864 else
13865   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13866 $as_echo "no" >&6; }
13867 fi
13868 
13869 
13870   test -n "$DF" && break
13871 done
13872 
13873   else
13874     # The variable is set, but is it from the command line or the environment?
13875 
13876     # Try to remove the string !DF! from our list.
13877     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DF!/}
13878     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
13879       # If it failed, the variable was not from the command line. Ignore it,
13880       # but warn the user (except for BASH, which is always set by the calling BASH).
13881       if test "xDF" != xBASH; then
13882         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DF from the environment. Use command line variables instead." >&5
13883 $as_echo "$as_me: WARNING: Ignoring value of DF from the environment. Use command line variables instead." >&2;}
13884       fi
13885       # Try to locate tool using the code snippet
13886       for ac_prog in df
13887 do
13888   # Extract the first word of "$ac_prog", so it can be a program name with args.
13889 set dummy $ac_prog; ac_word=$2
13890 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13891 $as_echo_n "checking for $ac_word... " >&6; }
13892 if ${ac_cv_path_DF+:} false; then :
13893   $as_echo_n "(cached) " >&6
13894 else
13895   case $DF in
13896   [\\/]* | ?:[\\/]*)
13897   ac_cv_path_DF="$DF" # Let the user override the test with a path.
13898   ;;
13899   *)
13900   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13901 for as_dir in $PATH
13902 do
13903   IFS=$as_save_IFS
13904   test -z "$as_dir" && as_dir=.
13905     for ac_exec_ext in '' $ac_executable_extensions; do
13906   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13907     ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
13908     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13909     break 2
13910   fi
13911 done
13912   done
13913 IFS=$as_save_IFS
13914 
13915   ;;
13916 esac
13917 fi
13918 DF=$ac_cv_path_DF
13919 if test -n "$DF"; then
13920   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
13921 $as_echo "$DF" >&6; }
13922 else
13923   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13924 $as_echo "no" >&6; }
13925 fi
13926 
13927 
13928   test -n "$DF" && break
13929 done
13930 
13931     else
13932       # If it succeeded, then it was overridden by the user. We will use it
13933       # for the tool.
13934 
13935       # First remove it from the list of overridden variables, so we can test
13936       # for unknown variables in the end.
13937       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13938 
13939       # Check if we try to supply an empty value
13940       if test "x$DF" = x; then
13941         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool DF= (no value)" >&5
13942 $as_echo "$as_me: Setting user supplied tool DF= (no value)" >&6;}
13943         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DF" >&5
13944 $as_echo_n "checking for DF... " >&6; }
13945         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
13946 $as_echo "disabled" >&6; }
13947       else
13948         # Check if the provided tool contains a complete path.
13949         tool_specified="$DF"
13950         tool_basename="${tool_specified##*/}"
13951         if test "x$tool_basename" = "x$tool_specified"; then
13952           # A command without a complete path is provided, search $PATH.
13953           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DF=$tool_basename" >&5
13954 $as_echo "$as_me: Will search for user supplied tool DF=$tool_basename" >&6;}
13955           # Extract the first word of "$tool_basename", so it can be a program name with args.
13956 set dummy $tool_basename; ac_word=$2
13957 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13958 $as_echo_n "checking for $ac_word... " >&6; }
13959 if ${ac_cv_path_DF+:} false; then :
13960   $as_echo_n "(cached) " >&6
13961 else
13962   case $DF in
13963   [\\/]* | ?:[\\/]*)
13964   ac_cv_path_DF="$DF" # Let the user override the test with a path.
13965   ;;
13966   *)
13967   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13968 for as_dir in $PATH
13969 do
13970   IFS=$as_save_IFS
13971   test -z "$as_dir" && as_dir=.
13972     for ac_exec_ext in '' $ac_executable_extensions; do
13973   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13974     ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
13975     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13976     break 2
13977   fi
13978 done
13979   done
13980 IFS=$as_save_IFS
13981 
13982   ;;
13983 esac
13984 fi
13985 DF=$ac_cv_path_DF
13986 if test -n "$DF"; then
13987   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
13988 $as_echo "$DF" >&6; }
13989 else
13990   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13991 $as_echo "no" >&6; }
13992 fi
13993 
13994 
13995           if test "x$DF" = x; then
13996             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13997           fi
13998         else
13999           # Otherwise we believe it is a complete path. Use it as it is.
14000           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DF=$tool_specified" >&5
14001 $as_echo "$as_me: Will use user supplied tool DF=$tool_specified" >&6;}
14002           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DF" >&5
14003 $as_echo_n "checking for DF... " >&6; }
14004           if test ! -x "$tool_specified"; then
14005             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
14006 $as_echo "not found" >&6; }
14007             as_fn_error $? "User supplied tool DF=$tool_specified does not exist or is not executable" "$LINENO" 5
14008           fi
14009           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
14010 $as_echo "$tool_specified" >&6; }
14011         fi
14012       fi
14013     fi
14014 
14015   fi
14016 
14017 
14018 
14019 
14020   # Publish this variable in the help.
14021 
14022 
14023   if [ -z "${CPIO+x}" ]; then
14024     # The variable is not set by user, try to locate tool using the code snippet
14025     for ac_prog in cpio bsdcpio
14026 do
14027   # Extract the first word of "$ac_prog", so it can be a program name with args.
14028 set dummy $ac_prog; ac_word=$2
14029 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14030 $as_echo_n "checking for $ac_word... " >&6; }
14031 if ${ac_cv_path_CPIO+:} false; then :
14032   $as_echo_n "(cached) " >&6
14033 else
14034   case $CPIO in
14035   [\\/]* | ?:[\\/]*)
14036   ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
14037   ;;
14038   *)
14039   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14040 for as_dir in $PATH
14041 do
14042   IFS=$as_save_IFS
14043   test -z "$as_dir" && as_dir=.
14044     for ac_exec_ext in '' $ac_executable_extensions; do
14045   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14046     ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
14047     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14048     break 2
14049   fi
14050 done
14051   done
14052 IFS=$as_save_IFS
14053 
14054   ;;
14055 esac
14056 fi
14057 CPIO=$ac_cv_path_CPIO
14058 if test -n "$CPIO"; then
14059   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
14060 $as_echo "$CPIO" >&6; }
14061 else
14062   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14063 $as_echo "no" >&6; }
14064 fi
14065 
14066 
14067   test -n "$CPIO" && break
14068 done
14069 
14070   else
14071     # The variable is set, but is it from the command line or the environment?
14072 
14073     # Try to remove the string !CPIO! from our list.
14074     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CPIO!/}
14075     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
14076       # If it failed, the variable was not from the command line. Ignore it,
14077       # but warn the user (except for BASH, which is always set by the calling BASH).
14078       if test "xCPIO" != xBASH; then
14079         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CPIO from the environment. Use command line variables instead." >&5
14080 $as_echo "$as_me: WARNING: Ignoring value of CPIO from the environment. Use command line variables instead." >&2;}
14081       fi
14082       # Try to locate tool using the code snippet
14083       for ac_prog in cpio bsdcpio
14084 do
14085   # Extract the first word of "$ac_prog", so it can be a program name with args.
14086 set dummy $ac_prog; ac_word=$2
14087 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14088 $as_echo_n "checking for $ac_word... " >&6; }
14089 if ${ac_cv_path_CPIO+:} false; then :
14090   $as_echo_n "(cached) " >&6
14091 else
14092   case $CPIO in
14093   [\\/]* | ?:[\\/]*)
14094   ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
14095   ;;
14096   *)
14097   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14098 for as_dir in $PATH
14099 do
14100   IFS=$as_save_IFS
14101   test -z "$as_dir" && as_dir=.
14102     for ac_exec_ext in '' $ac_executable_extensions; do
14103   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14104     ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
14105     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14106     break 2
14107   fi
14108 done
14109   done
14110 IFS=$as_save_IFS
14111 
14112   ;;
14113 esac
14114 fi
14115 CPIO=$ac_cv_path_CPIO
14116 if test -n "$CPIO"; then
14117   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
14118 $as_echo "$CPIO" >&6; }
14119 else
14120   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14121 $as_echo "no" >&6; }
14122 fi
14123 
14124 
14125   test -n "$CPIO" && break
14126 done
14127 
14128     else
14129       # If it succeeded, then it was overridden by the user. We will use it
14130       # for the tool.
14131 
14132       # First remove it from the list of overridden variables, so we can test
14133       # for unknown variables in the end.
14134       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
14135 
14136       # Check if we try to supply an empty value
14137       if test "x$CPIO" = x; then
14138         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CPIO= (no value)" >&5
14139 $as_echo "$as_me: Setting user supplied tool CPIO= (no value)" >&6;}
14140         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CPIO" >&5
14141 $as_echo_n "checking for CPIO... " >&6; }
14142         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
14143 $as_echo "disabled" >&6; }
14144       else
14145         # Check if the provided tool contains a complete path.
14146         tool_specified="$CPIO"
14147         tool_basename="${tool_specified##*/}"
14148         if test "x$tool_basename" = "x$tool_specified"; then
14149           # A command without a complete path is provided, search $PATH.
14150           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CPIO=$tool_basename" >&5
14151 $as_echo "$as_me: Will search for user supplied tool CPIO=$tool_basename" >&6;}
14152           # Extract the first word of "$tool_basename", so it can be a program name with args.
14153 set dummy $tool_basename; ac_word=$2
14154 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14155 $as_echo_n "checking for $ac_word... " >&6; }
14156 if ${ac_cv_path_CPIO+:} false; then :
14157   $as_echo_n "(cached) " >&6
14158 else
14159   case $CPIO in
14160   [\\/]* | ?:[\\/]*)
14161   ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
14162   ;;
14163   *)
14164   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14165 for as_dir in $PATH
14166 do
14167   IFS=$as_save_IFS
14168   test -z "$as_dir" && as_dir=.
14169     for ac_exec_ext in '' $ac_executable_extensions; do
14170   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14171     ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
14172     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14173     break 2
14174   fi
14175 done
14176   done
14177 IFS=$as_save_IFS
14178 
14179   ;;
14180 esac
14181 fi
14182 CPIO=$ac_cv_path_CPIO
14183 if test -n "$CPIO"; then
14184   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
14185 $as_echo "$CPIO" >&6; }
14186 else
14187   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14188 $as_echo "no" >&6; }
14189 fi
14190 
14191 
14192           if test "x$CPIO" = x; then
14193             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
14194           fi
14195         else
14196           # Otherwise we believe it is a complete path. Use it as it is.
14197           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CPIO=$tool_specified" >&5
14198 $as_echo "$as_me: Will use user supplied tool CPIO=$tool_specified" >&6;}
14199           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CPIO" >&5
14200 $as_echo_n "checking for CPIO... " >&6; }
14201           if test ! -x "$tool_specified"; then
14202             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
14203 $as_echo "not found" >&6; }
14204             as_fn_error $? "User supplied tool CPIO=$tool_specified does not exist or is not executable" "$LINENO" 5
14205           fi
14206           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
14207 $as_echo "$tool_specified" >&6; }
14208         fi
14209       fi
14210     fi
14211 
14212   fi
14213 
14214 
14215 
14216 
14217   # Publish this variable in the help.
14218 
14219 
14220   if [ -z "${NICE+x}" ]; then
14221     # The variable is not set by user, try to locate tool using the code snippet
14222     for ac_prog in nice
14223 do
14224   # Extract the first word of "$ac_prog", so it can be a program name with args.
14225 set dummy $ac_prog; ac_word=$2
14226 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14227 $as_echo_n "checking for $ac_word... " >&6; }
14228 if ${ac_cv_path_NICE+:} false; then :
14229   $as_echo_n "(cached) " >&6
14230 else
14231   case $NICE in
14232   [\\/]* | ?:[\\/]*)
14233   ac_cv_path_NICE="$NICE" # Let the user override the test with a path.
14234   ;;
14235   *)
14236   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14237 for as_dir in $PATH
14238 do
14239   IFS=$as_save_IFS
14240   test -z "$as_dir" && as_dir=.
14241     for ac_exec_ext in '' $ac_executable_extensions; do
14242   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14243     ac_cv_path_NICE="$as_dir/$ac_word$ac_exec_ext"
14244     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14245     break 2
14246   fi
14247 done
14248   done
14249 IFS=$as_save_IFS
14250 
14251   ;;
14252 esac
14253 fi
14254 NICE=$ac_cv_path_NICE
14255 if test -n "$NICE"; then
14256   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NICE" >&5
14257 $as_echo "$NICE" >&6; }
14258 else
14259   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14260 $as_echo "no" >&6; }
14261 fi
14262 
14263 
14264   test -n "$NICE" && break
14265 done
14266 
14267   else
14268     # The variable is set, but is it from the command line or the environment?
14269 
14270     # Try to remove the string !NICE! from our list.
14271     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!NICE!/}
14272     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
14273       # If it failed, the variable was not from the command line. Ignore it,
14274       # but warn the user (except for BASH, which is always set by the calling BASH).
14275       if test "xNICE" != xBASH; then
14276         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of NICE from the environment. Use command line variables instead." >&5
14277 $as_echo "$as_me: WARNING: Ignoring value of NICE from the environment. Use command line variables instead." >&2;}
14278       fi
14279       # Try to locate tool using the code snippet
14280       for ac_prog in nice
14281 do
14282   # Extract the first word of "$ac_prog", so it can be a program name with args.
14283 set dummy $ac_prog; ac_word=$2
14284 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14285 $as_echo_n "checking for $ac_word... " >&6; }
14286 if ${ac_cv_path_NICE+:} false; then :
14287   $as_echo_n "(cached) " >&6
14288 else
14289   case $NICE in
14290   [\\/]* | ?:[\\/]*)
14291   ac_cv_path_NICE="$NICE" # Let the user override the test with a path.
14292   ;;
14293   *)
14294   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14295 for as_dir in $PATH
14296 do
14297   IFS=$as_save_IFS
14298   test -z "$as_dir" && as_dir=.
14299     for ac_exec_ext in '' $ac_executable_extensions; do
14300   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14301     ac_cv_path_NICE="$as_dir/$ac_word$ac_exec_ext"
14302     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14303     break 2
14304   fi
14305 done
14306   done
14307 IFS=$as_save_IFS
14308 
14309   ;;
14310 esac
14311 fi
14312 NICE=$ac_cv_path_NICE
14313 if test -n "$NICE"; then
14314   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NICE" >&5
14315 $as_echo "$NICE" >&6; }
14316 else
14317   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14318 $as_echo "no" >&6; }
14319 fi
14320 
14321 
14322   test -n "$NICE" && break
14323 done
14324 
14325     else
14326       # If it succeeded, then it was overridden by the user. We will use it
14327       # for the tool.
14328 
14329       # First remove it from the list of overridden variables, so we can test
14330       # for unknown variables in the end.
14331       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
14332 
14333       # Check if we try to supply an empty value
14334       if test "x$NICE" = x; then
14335         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool NICE= (no value)" >&5
14336 $as_echo "$as_me: Setting user supplied tool NICE= (no value)" >&6;}
14337         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NICE" >&5
14338 $as_echo_n "checking for NICE... " >&6; }
14339         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
14340 $as_echo "disabled" >&6; }
14341       else
14342         # Check if the provided tool contains a complete path.
14343         tool_specified="$NICE"
14344         tool_basename="${tool_specified##*/}"
14345         if test "x$tool_basename" = "x$tool_specified"; then
14346           # A command without a complete path is provided, search $PATH.
14347           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool NICE=$tool_basename" >&5
14348 $as_echo "$as_me: Will search for user supplied tool NICE=$tool_basename" >&6;}
14349           # Extract the first word of "$tool_basename", so it can be a program name with args.
14350 set dummy $tool_basename; ac_word=$2
14351 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14352 $as_echo_n "checking for $ac_word... " >&6; }
14353 if ${ac_cv_path_NICE+:} false; then :
14354   $as_echo_n "(cached) " >&6
14355 else
14356   case $NICE in
14357   [\\/]* | ?:[\\/]*)
14358   ac_cv_path_NICE="$NICE" # Let the user override the test with a path.
14359   ;;
14360   *)
14361   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14362 for as_dir in $PATH
14363 do
14364   IFS=$as_save_IFS
14365   test -z "$as_dir" && as_dir=.
14366     for ac_exec_ext in '' $ac_executable_extensions; do
14367   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14368     ac_cv_path_NICE="$as_dir/$ac_word$ac_exec_ext"
14369     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14370     break 2
14371   fi
14372 done
14373   done
14374 IFS=$as_save_IFS
14375 
14376   ;;
14377 esac
14378 fi
14379 NICE=$ac_cv_path_NICE
14380 if test -n "$NICE"; then
14381   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NICE" >&5
14382 $as_echo "$NICE" >&6; }
14383 else
14384   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14385 $as_echo "no" >&6; }
14386 fi
14387 
14388 
14389           if test "x$NICE" = x; then
14390             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
14391           fi
14392         else
14393           # Otherwise we believe it is a complete path. Use it as it is.
14394           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool NICE=$tool_specified" >&5
14395 $as_echo "$as_me: Will use user supplied tool NICE=$tool_specified" >&6;}
14396           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NICE" >&5
14397 $as_echo_n "checking for NICE... " >&6; }
14398           if test ! -x "$tool_specified"; then
14399             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
14400 $as_echo "not found" >&6; }
14401             as_fn_error $? "User supplied tool NICE=$tool_specified does not exist or is not executable" "$LINENO" 5
14402           fi
14403           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
14404 $as_echo "$tool_specified" >&6; }
14405         fi
14406       fi
14407     fi
14408 
14409   fi
14410 
14411 
14412 
14413 
14414 # Now we can determine OpenJDK build and target platforms. This is required to
14415 # have early on.
14416 # Make sure we can run config.sub.
14417 $SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
14418   as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5
14419 
14420 { $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
14421 $as_echo_n "checking build system type... " >&6; }
14422 if ${ac_cv_build+:} false; then :
14423   $as_echo_n "(cached) " >&6
14424 else
14425   ac_build_alias=$build_alias
14426 test "x$ac_build_alias" = x &&
14427   ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
14428 test "x$ac_build_alias" = x &&
14429   as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5
14430 ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
14431   as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5
14432 
14433 fi
14434 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
14435 $as_echo "$ac_cv_build" >&6; }
14436 case $ac_cv_build in
14437 *-*-*) ;;
14438 *) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;;
14439 esac
14440 build=$ac_cv_build
14441 ac_save_IFS=$IFS; IFS='-'
14442 set x $ac_cv_build
14443 shift
14444 build_cpu=$1
14445 build_vendor=$2
14446 shift; shift
14447 # Remember, the first character of IFS is used to create $*,
14448 # except with old shells:
14449 build_os=$*
14450 IFS=$ac_save_IFS
14451 case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
14452 
14453 
14454 { $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
14455 $as_echo_n "checking host system type... " >&6; }
14456 if ${ac_cv_host+:} false; then :
14457   $as_echo_n "(cached) " >&6
14458 else
14459   if test "x$host_alias" = x; then
14460   ac_cv_host=$ac_cv_build
14461 else
14462   ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
14463     as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5
14464 fi
14465 
14466 fi
14467 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
14468 $as_echo "$ac_cv_host" >&6; }
14469 case $ac_cv_host in
14470 *-*-*) ;;
14471 *) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;;
14472 esac
14473 host=$ac_cv_host
14474 ac_save_IFS=$IFS; IFS='-'
14475 set x $ac_cv_host
14476 shift
14477 host_cpu=$1
14478 host_vendor=$2
14479 shift; shift
14480 # Remember, the first character of IFS is used to create $*,
14481 # except with old shells:
14482 host_os=$*
14483 IFS=$ac_save_IFS
14484 case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
14485 
14486 
14487 { $as_echo "$as_me:${as_lineno-$LINENO}: checking target system type" >&5
14488 $as_echo_n "checking target system type... " >&6; }
14489 if ${ac_cv_target+:} false; then :
14490   $as_echo_n "(cached) " >&6
14491 else
14492   if test "x$target_alias" = x; then
14493   ac_cv_target=$ac_cv_host
14494 else
14495   ac_cv_target=`$SHELL "$ac_aux_dir/config.sub" $target_alias` ||
14496     as_fn_error $? "$SHELL $ac_aux_dir/config.sub $target_alias failed" "$LINENO" 5
14497 fi
14498 
14499 fi
14500 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_target" >&5
14501 $as_echo "$ac_cv_target" >&6; }
14502 case $ac_cv_target in
14503 *-*-*) ;;
14504 *) as_fn_error $? "invalid value of canonical target" "$LINENO" 5;;
14505 esac
14506 target=$ac_cv_target
14507 ac_save_IFS=$IFS; IFS='-'
14508 set x $ac_cv_target
14509 shift
14510 target_cpu=$1
14511 target_vendor=$2
14512 shift; shift
14513 # Remember, the first character of IFS is used to create $*,
14514 # except with old shells:
14515 target_os=$*
14516 IFS=$ac_save_IFS
14517 case $target_os in *\ *) target_os=`echo "$target_os" | sed 's/ /-/g'`;; esac
14518 
14519 
14520 # The aliases save the names the user supplied, while $host etc.
14521 # will get canonicalized.
14522 test -n "$target_alias" &&
14523   test "$program_prefix$program_suffix$program_transform_name" = \
14524     NONENONEs,x,x, &&
14525   program_prefix=${target_alias}-
14526 
14527   # Figure out the build and target systems. # Note that in autoconf terminology, "build" is obvious, but "target"
14528   # is confusing; it assumes you are cross-compiling a cross-compiler (!)  and "target" is thus the target of the
14529   # product you're building. The target of this build is called "host". Since this is confusing to most people, we
14530   # have not adopted that system, but use "target" as the platform we are building for. In some places though we need
14531   # to use the configure naming style.
14532 
14533 
14534 
14535 
14536 
14537   # Copy the autoconf trip/quadruplet verbatim to OPENJDK_TARGET_AUTOCONF_NAME
14538   # (from the autoconf "host") and OPENJDK_BUILD_AUTOCONF_NAME
14539   # Note that we might later on rewrite e.g. OPENJDK_TARGET_CPU due to reduced build,
14540   # but this will not change the value of OPENJDK_TARGET_AUTOCONF_NAME.
14541   OPENJDK_TARGET_AUTOCONF_NAME="$host"
14542   OPENJDK_BUILD_AUTOCONF_NAME="$build"
14543 
14544 
14545 
14546   # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
14547 
14548   case "$build_os" in
14549     *linux*)
14550       VAR_OS=linux
14551       VAR_OS_TYPE=unix
14552       ;;
14553     *solaris*)
14554       VAR_OS=solaris
14555       VAR_OS_TYPE=unix
14556       ;;
14557     *darwin*)
14558       VAR_OS=macosx
14559       VAR_OS_TYPE=unix
14560       ;;
14561     *bsd*)
14562       VAR_OS=bsd
14563       VAR_OS_TYPE=unix
14564       ;;
14565     *cygwin*)
14566       VAR_OS=windows
14567       VAR_OS_ENV=windows.cygwin
14568       ;;
14569     *mingw*)
14570       VAR_OS=windows
14571       VAR_OS_ENV=windows.msys
14572       ;;
14573     *aix*)
14574       VAR_OS=aix
14575       VAR_OS_TYPE=unix
14576       ;;
14577     *)
14578       as_fn_error $? "unsupported operating system $build_os" "$LINENO" 5
14579       ;;
14580   esac
14581 
14582 
14583   # First argument is the cpu name from the trip/quad
14584   case "$build_cpu" in
14585     x86_64)
14586       VAR_CPU=x86_64
14587       VAR_CPU_ARCH=x86
14588       VAR_CPU_BITS=64
14589       VAR_CPU_ENDIAN=little
14590       ;;
14591     i?86)
14592       VAR_CPU=x86
14593       VAR_CPU_ARCH=x86
14594       VAR_CPU_BITS=32
14595       VAR_CPU_ENDIAN=little
14596       ;;
14597     arm*)
14598       VAR_CPU=arm
14599       VAR_CPU_ARCH=arm
14600       VAR_CPU_BITS=32
14601       VAR_CPU_ENDIAN=little
14602       ;;
14603     aarch64)
14604       VAR_CPU=aarch64
14605       VAR_CPU_ARCH=aarch64
14606       VAR_CPU_BITS=64
14607       VAR_CPU_ENDIAN=little
14608       ;;
14609     powerpc)
14610       VAR_CPU=ppc
14611       VAR_CPU_ARCH=ppc
14612       VAR_CPU_BITS=32
14613       VAR_CPU_ENDIAN=big
14614       ;;
14615     powerpc64)
14616       VAR_CPU=ppc64
14617       VAR_CPU_ARCH=ppc
14618       VAR_CPU_BITS=64
14619       VAR_CPU_ENDIAN=big
14620       ;;
14621     powerpc64le)
14622       VAR_CPU=ppc64
14623       VAR_CPU_ARCH=ppc
14624       VAR_CPU_BITS=64
14625       VAR_CPU_ENDIAN=little
14626       ;;
14627     s390)
14628       VAR_CPU=s390
14629       VAR_CPU_ARCH=s390
14630       VAR_CPU_BITS=32
14631       VAR_CPU_ENDIAN=big
14632       ;;
14633     s390x)
14634       VAR_CPU=s390x
14635       VAR_CPU_ARCH=s390
14636       VAR_CPU_BITS=64
14637       VAR_CPU_ENDIAN=big
14638       ;;
14639     sparc)
14640       VAR_CPU=sparc
14641       VAR_CPU_ARCH=sparc
14642       VAR_CPU_BITS=32
14643       VAR_CPU_ENDIAN=big
14644       ;;
14645     sparcv9|sparc64)
14646       VAR_CPU=sparcv9
14647       VAR_CPU_ARCH=sparc
14648       VAR_CPU_BITS=64
14649       VAR_CPU_ENDIAN=big
14650       ;;
14651     *)
14652       as_fn_error $? "unsupported cpu $build_cpu" "$LINENO" 5
14653       ;;
14654   esac
14655 
14656   # ..and setup our own variables. (Do this explicitely to facilitate searching)
14657   OPENJDK_BUILD_OS="$VAR_OS"
14658   if test "x$VAR_OS_TYPE" != x; then
14659     OPENJDK_BUILD_OS_TYPE="$VAR_OS_TYPE"
14660   else
14661     OPENJDK_BUILD_OS_TYPE="$VAR_OS"
14662   fi
14663   if test "x$VAR_OS_ENV" != x; then
14664     OPENJDK_BUILD_OS_ENV="$VAR_OS_ENV"
14665   else
14666     OPENJDK_BUILD_OS_ENV="$VAR_OS"
14667   fi
14668   OPENJDK_BUILD_CPU="$VAR_CPU"
14669   OPENJDK_BUILD_CPU_ARCH="$VAR_CPU_ARCH"
14670   OPENJDK_BUILD_CPU_BITS="$VAR_CPU_BITS"
14671   OPENJDK_BUILD_CPU_ENDIAN="$VAR_CPU_ENDIAN"
14672 
14673 
14674 
14675 
14676 
14677 
14678 
14679 
14680   { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-build os-cpu" >&5
14681 $as_echo_n "checking openjdk-build os-cpu... " >&6; }
14682   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&5
14683 $as_echo "$OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&6; }
14684 
14685   # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
14686 
14687   case "$host_os" in
14688     *linux*)
14689       VAR_OS=linux
14690       VAR_OS_TYPE=unix
14691       ;;
14692     *solaris*)
14693       VAR_OS=solaris
14694       VAR_OS_TYPE=unix
14695       ;;
14696     *darwin*)
14697       VAR_OS=macosx
14698       VAR_OS_TYPE=unix
14699       ;;
14700     *bsd*)
14701       VAR_OS=bsd
14702       VAR_OS_TYPE=unix
14703       ;;
14704     *cygwin*)
14705       VAR_OS=windows
14706       VAR_OS_ENV=windows.cygwin
14707       ;;
14708     *mingw*)
14709       VAR_OS=windows
14710       VAR_OS_ENV=windows.msys
14711       ;;
14712     *aix*)
14713       VAR_OS=aix
14714       VAR_OS_TYPE=unix
14715       ;;
14716     *)
14717       as_fn_error $? "unsupported operating system $host_os" "$LINENO" 5
14718       ;;
14719   esac
14720 
14721 
14722   # First argument is the cpu name from the trip/quad
14723   case "$host_cpu" in
14724     x86_64)
14725       VAR_CPU=x86_64
14726       VAR_CPU_ARCH=x86
14727       VAR_CPU_BITS=64
14728       VAR_CPU_ENDIAN=little
14729       ;;
14730     i?86)
14731       VAR_CPU=x86
14732       VAR_CPU_ARCH=x86
14733       VAR_CPU_BITS=32
14734       VAR_CPU_ENDIAN=little
14735       ;;
14736     arm*)
14737       VAR_CPU=arm
14738       VAR_CPU_ARCH=arm
14739       VAR_CPU_BITS=32
14740       VAR_CPU_ENDIAN=little
14741       ;;
14742     aarch64)
14743       VAR_CPU=aarch64
14744       VAR_CPU_ARCH=aarch64
14745       VAR_CPU_BITS=64
14746       VAR_CPU_ENDIAN=little
14747       ;;
14748     powerpc)
14749       VAR_CPU=ppc
14750       VAR_CPU_ARCH=ppc
14751       VAR_CPU_BITS=32
14752       VAR_CPU_ENDIAN=big
14753       ;;
14754     powerpc64)
14755       VAR_CPU=ppc64
14756       VAR_CPU_ARCH=ppc
14757       VAR_CPU_BITS=64
14758       VAR_CPU_ENDIAN=big
14759       ;;
14760     powerpc64le)
14761       VAR_CPU=ppc64
14762       VAR_CPU_ARCH=ppc
14763       VAR_CPU_BITS=64
14764       VAR_CPU_ENDIAN=little
14765       ;;
14766     s390)
14767       VAR_CPU=s390
14768       VAR_CPU_ARCH=s390
14769       VAR_CPU_BITS=32
14770       VAR_CPU_ENDIAN=big
14771       ;;
14772     s390x)
14773       VAR_CPU=s390x
14774       VAR_CPU_ARCH=s390
14775       VAR_CPU_BITS=64
14776       VAR_CPU_ENDIAN=big
14777       ;;
14778     sparc)
14779       VAR_CPU=sparc
14780       VAR_CPU_ARCH=sparc
14781       VAR_CPU_BITS=32
14782       VAR_CPU_ENDIAN=big
14783       ;;
14784     sparcv9|sparc64)
14785       VAR_CPU=sparcv9
14786       VAR_CPU_ARCH=sparc
14787       VAR_CPU_BITS=64
14788       VAR_CPU_ENDIAN=big
14789       ;;
14790     *)
14791       as_fn_error $? "unsupported cpu $host_cpu" "$LINENO" 5
14792       ;;
14793   esac
14794 
14795   # ... and setup our own variables. (Do this explicitely to facilitate searching)
14796   OPENJDK_TARGET_OS="$VAR_OS"
14797   if test "x$VAR_OS_TYPE" != x; then
14798     OPENJDK_TARGET_OS_TYPE="$VAR_OS_TYPE"
14799   else
14800     OPENJDK_TARGET_OS_TYPE="$VAR_OS"
14801   fi
14802   if test "x$VAR_OS_ENV" != x; then
14803     OPENJDK_TARGET_OS_ENV="$VAR_OS_ENV"
14804   else
14805     OPENJDK_TARGET_OS_ENV="$VAR_OS"
14806   fi
14807   OPENJDK_TARGET_CPU="$VAR_CPU"
14808   OPENJDK_TARGET_CPU_ARCH="$VAR_CPU_ARCH"
14809   OPENJDK_TARGET_CPU_BITS="$VAR_CPU_BITS"
14810   OPENJDK_TARGET_CPU_ENDIAN="$VAR_CPU_ENDIAN"
14811 
14812 
14813 
14814 
14815 
14816 
14817 
14818 
14819   { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-target os-cpu" >&5
14820 $as_echo_n "checking openjdk-target os-cpu... " >&6; }
14821   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&5
14822 $as_echo "$OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&6; }
14823 
14824 
14825 
14826 # Check whether --with-target-bits was given.
14827 if test "${with_target_bits+set}" = set; then :
14828   withval=$with_target_bits;
14829 fi
14830 
14831 
14832   # We have three types of compiles:
14833   # native  == normal compilation, target system == build system
14834   # cross   == traditional cross compilation, target system != build system; special toolchain needed
14835   # reduced == using native compilers, but with special flags (e.g. -m32) to produce 32-bit builds on 64-bit machines
14836   #
14837   if test "x$OPENJDK_BUILD_AUTOCONF_NAME" != "x$OPENJDK_TARGET_AUTOCONF_NAME"; then
14838     # We're doing a proper cross-compilation
14839     COMPILE_TYPE="cross"
14840   else
14841     COMPILE_TYPE="native"
14842   fi
14843 
14844   if test "x$with_target_bits" != x; then
14845     if test "x$COMPILE_TYPE" = "xcross"; then
14846       as_fn_error $? "It is not possible to combine --with-target-bits=X and proper cross-compilation. Choose either." "$LINENO" 5
14847     fi
14848 
14849     if test "x$with_target_bits" = x32 && test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
14850       # A reduced build is requested
14851       COMPILE_TYPE="reduced"
14852       OPENJDK_TARGET_CPU_BITS=32
14853       if test "x$OPENJDK_TARGET_CPU_ARCH" = "xx86"; then
14854         OPENJDK_TARGET_CPU=x86
14855       elif test "x$OPENJDK_TARGET_CPU_ARCH" = "xsparc"; then
14856         OPENJDK_TARGET_CPU=sparc
14857       else
14858         as_fn_error $? "Reduced build (--with-target-bits=32) is only supported on x86_64 and sparcv9" "$LINENO" 5
14859       fi
14860     elif test "x$with_target_bits" = x64 && test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
14861       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
14862     elif test "x$with_target_bits" = "x$OPENJDK_TARGET_CPU_BITS"; then
14863       { $as_echo "$as_me:${as_lineno-$LINENO}: --with-target-bits are set to build platform address size; argument has no meaning" >&5
14864 $as_echo "$as_me: --with-target-bits are set to build platform address size; argument has no meaning" >&6;}
14865     else
14866       as_fn_error $? "--with-target-bits can only be 32 or 64, you specified $with_target_bits!" "$LINENO" 5
14867     fi
14868   fi
14869 
14870 
14871   { $as_echo "$as_me:${as_lineno-$LINENO}: checking compilation type" >&5
14872 $as_echo_n "checking compilation type... " >&6; }
14873   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMPILE_TYPE" >&5
14874 $as_echo "$COMPILE_TYPE" >&6; }
14875 
14876 
14877   if test "x$OPENJDK_TARGET_OS" = "xsolaris"; then
14878     REQUIRED_OS_NAME=SunOS
14879     REQUIRED_OS_VERSION=5.10
14880   fi
14881   if test "x$OPENJDK_TARGET_OS" = "xlinux"; then
14882     REQUIRED_OS_NAME=Linux
14883     REQUIRED_OS_VERSION=2.6
14884   fi
14885   if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
14886     REQUIRED_OS_NAME=Windows
14887     if test "x$OPENJDK_TARGET_CPU_BITS" = "x64"; then
14888       REQUIRED_OS_VERSION=5.2
14889     else
14890       REQUIRED_OS_VERSION=5.1
14891     fi
14892   fi
14893   if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
14894     REQUIRED_OS_NAME=Darwin
14895     REQUIRED_OS_VERSION=11.2
14896   fi
14897 
14898 
14899 
14900 
14901 
14902   # Also store the legacy naming of the cpu.
14903   # Ie i586 and amd64 instead of x86 and x86_64
14904   OPENJDK_TARGET_CPU_LEGACY="$OPENJDK_TARGET_CPU"
14905   if test "x$OPENJDK_TARGET_CPU" = xx86; then
14906     OPENJDK_TARGET_CPU_LEGACY="i586"
14907   elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
14908     # On all platforms except MacOSX replace x86_64 with amd64.
14909     OPENJDK_TARGET_CPU_LEGACY="amd64"
14910   fi
14911 
14912 
14913   # And the second legacy naming of the cpu.
14914   # Ie i386 and amd64 instead of x86 and x86_64.
14915   OPENJDK_TARGET_CPU_LEGACY_LIB="$OPENJDK_TARGET_CPU"
14916   if test "x$OPENJDK_TARGET_CPU" = xx86; then
14917     OPENJDK_TARGET_CPU_LEGACY_LIB="i386"
14918   elif test "x$OPENJDK_TARGET_CPU" = xx86_64; then
14919     OPENJDK_TARGET_CPU_LEGACY_LIB="amd64"
14920   fi
14921 
14922 
14923   # This is the name of the cpu (but using i386 and amd64 instead of
14924   # x86 and x86_64, respectively), preceeded by a /, to be used when
14925   # locating libraries. On macosx, it's empty, though.
14926   OPENJDK_TARGET_CPU_LIBDIR="/$OPENJDK_TARGET_CPU_LEGACY_LIB"
14927   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
14928     OPENJDK_TARGET_CPU_LIBDIR=""
14929   fi
14930 
14931 
14932   # OPENJDK_TARGET_CPU_ISADIR is normally empty. On 64-bit Solaris systems, it is set to
14933   # /amd64 or /sparcv9. This string is appended to some library paths, like this:
14934   # /usr/lib${OPENJDK_TARGET_CPU_ISADIR}/libexample.so
14935   OPENJDK_TARGET_CPU_ISADIR=""
14936   if test "x$OPENJDK_TARGET_OS" = xsolaris; then
14937     if test "x$OPENJDK_TARGET_CPU" = xx86_64; then
14938       OPENJDK_TARGET_CPU_ISADIR="/amd64"
14939     elif test "x$OPENJDK_TARGET_CPU" = xsparcv9; then
14940       OPENJDK_TARGET_CPU_ISADIR="/sparcv9"
14941     fi
14942   fi
14943 
14944 
14945   # Setup OPENJDK_TARGET_CPU_OSARCH, which is used to set the os.arch Java system property
14946   OPENJDK_TARGET_CPU_OSARCH="$OPENJDK_TARGET_CPU"
14947   if test "x$OPENJDK_TARGET_OS" = xlinux && test "x$OPENJDK_TARGET_CPU" = xx86; then
14948     # On linux only, we replace x86 with i386.
14949     OPENJDK_TARGET_CPU_OSARCH="i386"
14950   elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
14951     # On all platforms except macosx, we replace x86_64 with amd64.
14952     OPENJDK_TARGET_CPU_OSARCH="amd64"
14953   fi
14954 
14955 
14956   OPENJDK_TARGET_CPU_JLI="$OPENJDK_TARGET_CPU"
14957   if test "x$OPENJDK_TARGET_CPU" = xx86; then
14958     OPENJDK_TARGET_CPU_JLI="i386"
14959   elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
14960     # On all platforms except macosx, we replace x86_64 with amd64.
14961     OPENJDK_TARGET_CPU_JLI="amd64"
14962   fi
14963   # Now setup the -D flags for building libjli.
14964   OPENJDK_TARGET_CPU_JLI_CFLAGS="-DLIBARCHNAME='\"$OPENJDK_TARGET_CPU_JLI\"'"
14965   if test "x$OPENJDK_TARGET_OS" = xsolaris; then
14966     if test "x$OPENJDK_TARGET_CPU_ARCH" = xsparc; then
14967       OPENJDK_TARGET_CPU_JLI_CFLAGS="$OPENJDK_TARGET_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"sparc\"' -DLIBARCH64NAME='\"sparcv9\"'"
14968     elif test "x$OPENJDK_TARGET_CPU_ARCH" = xx86; then
14969       OPENJDK_TARGET_CPU_JLI_CFLAGS="$OPENJDK_TARGET_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"i386\"' -DLIBARCH64NAME='\"amd64\"'"
14970     fi
14971   fi
14972 
14973 
14974   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
14975       OPENJDK_TARGET_OS_EXPORT_DIR=macosx
14976   else
14977       OPENJDK_TARGET_OS_EXPORT_DIR=${OPENJDK_TARGET_OS_TYPE}
14978   fi
14979 
14980 
14981   if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
14982     A_LP64="LP64:="
14983     # -D_LP64=1 is only set on linux and mac. Setting on windows causes diff in
14984     # unpack200.exe
14985     if test "x$OPENJDK_TARGET_OS" = xlinux || test "x$OPENJDK_TARGET_OS" = xmacosx; then
14986       ADD_LP64="-D_LP64=1"
14987     fi
14988   fi
14989   LP64=$A_LP64
14990 
14991 
14992   if test "x$COMPILE_TYPE" = "xcross"; then
14993     # FIXME: ... or should this include reduced builds..?
14994     DEFINE_CROSS_COMPILE_ARCH="CROSS_COMPILE_ARCH:=$OPENJDK_TARGET_CPU_LEGACY"
14995   else
14996     DEFINE_CROSS_COMPILE_ARCH=""
14997   fi
14998 
14999 
15000   # ZERO_ARCHDEF is used to enable architecture-specific code
15001   case "${OPENJDK_TARGET_CPU}" in
15002     ppc)     ZERO_ARCHDEF=PPC32 ;;
15003     ppc64)   ZERO_ARCHDEF=PPC64 ;;
15004     s390*)   ZERO_ARCHDEF=S390  ;;
15005     sparc*)  ZERO_ARCHDEF=SPARC ;;
15006     x86_64*) ZERO_ARCHDEF=AMD64 ;;
15007     x86)     ZERO_ARCHDEF=IA32  ;;
15008     *)      ZERO_ARCHDEF=$(echo "${OPENJDK_TARGET_CPU_LEGACY_LIB}" | tr a-z A-Z)
15009   esac
15010 
15011 
15012 
15013 
15014 # Continue setting up basic stuff. Most remaining code require fundamental tools.
15015 
15016   # Save the current directory this script was started from
15017   CURDIR="$PWD"
15018 
15019   # We might need to rewrite ORIGINAL_PATH, if it includes "#", to quote them
15020   # for make. We couldn't do this when we retrieved ORIGINAL_PATH, since SED
15021   # was not available at that time.
15022   REWRITTEN_PATH=`$ECHO "$ORIGINAL_PATH" | $SED -e 's/#/\\\\#/g'`
15023   if test "x$REWRITTEN_PATH" != "x$ORIGINAL_PATH"; then
15024     ORIGINAL_PATH="$REWRITTEN_PATH"
15025     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting ORIGINAL_PATH to $REWRITTEN_PATH" >&5
15026 $as_echo "$as_me: Rewriting ORIGINAL_PATH to $REWRITTEN_PATH" >&6;}
15027   fi
15028 
15029   if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
15030     PATH_SEP=";"
15031 
15032   SRC_ROOT_LENGTH=`$THEPWDCMD -L|$WC -m`
15033   if test $SRC_ROOT_LENGTH -gt 100; then
15034     as_fn_error $? "Your base path is too long. It is $SRC_ROOT_LENGTH characters long, but only 100 is supported" "$LINENO" 5
15035   fi
15036 
15037   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15038     { $as_echo "$as_me:${as_lineno-$LINENO}: checking cygwin release" >&5
15039 $as_echo_n "checking cygwin release... " >&6; }
15040     CYGWIN_VERSION=`$UNAME -r`
15041     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_VERSION" >&5
15042 $as_echo "$CYGWIN_VERSION" >&6; }
15043     WINDOWS_ENV_VENDOR='cygwin'
15044     WINDOWS_ENV_VERSION="$CYGWIN_VERSION"
15045 
15046     CYGWIN_VERSION_OLD=`$ECHO $CYGWIN_VERSION | $GREP -e '^1\.0-6'`
15047     if test "x$CYGWIN_VERSION_OLD" != x; then
15048       { $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
15049 $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;}
15050       as_fn_error $? "Cannot continue" "$LINENO" 5
15051     fi
15052     if test "x$CYGPATH" = x; then
15053       as_fn_error $? "Something is wrong with your cygwin installation since I cannot find cygpath.exe in your path" "$LINENO" 5
15054     fi
15055     { $as_echo "$as_me:${as_lineno-$LINENO}: checking cygwin root directory as unix-style path" >&5
15056 $as_echo_n "checking cygwin root directory as unix-style path... " >&6; }
15057     # The cmd output ends with Windows line endings (CR/LF), the grep command will strip that away
15058     cygwin_winpath_root=`cd / ; cmd /c cd | grep ".*"`
15059     # Force cygpath to report the proper root by including a trailing space, and then stripping it off again.
15060     CYGWIN_ROOT_PATH=`$CYGPATH -u "$cygwin_winpath_root " | $CUT -f 1 -d " "`
15061     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_ROOT_PATH" >&5
15062 $as_echo "$CYGWIN_ROOT_PATH" >&6; }
15063     WINDOWS_ENV_ROOT_PATH="$CYGWIN_ROOT_PATH"
15064     test_cygdrive_prefix=`$ECHO $CYGWIN_ROOT_PATH | $GREP ^/cygdrive/`
15065     if test "x$test_cygdrive_prefix" = x; then
15066       as_fn_error $? "Your cygdrive prefix is not /cygdrive. This is currently not supported. Change with mount -c." "$LINENO" 5
15067     fi
15068   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15069     { $as_echo "$as_me:${as_lineno-$LINENO}: checking msys release" >&5
15070 $as_echo_n "checking msys release... " >&6; }
15071     MSYS_VERSION=`$UNAME -r`
15072     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSYS_VERSION" >&5
15073 $as_echo "$MSYS_VERSION" >&6; }
15074 
15075     WINDOWS_ENV_VENDOR='msys'
15076     WINDOWS_ENV_VERSION="$MSYS_VERSION"
15077 
15078     { $as_echo "$as_me:${as_lineno-$LINENO}: checking msys root directory as unix-style path" >&5
15079 $as_echo_n "checking msys root directory as unix-style path... " >&6; }
15080     # The cmd output ends with Windows line endings (CR/LF), the grep command will strip that away
15081     MSYS_ROOT_PATH=`cd / ; cmd /c cd | grep ".*"`
15082 
15083   windows_path="$MSYS_ROOT_PATH"
15084   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15085     unix_path=`$CYGPATH -u "$windows_path"`
15086     MSYS_ROOT_PATH="$unix_path"
15087   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15088     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15089     MSYS_ROOT_PATH="$unix_path"
15090   fi
15091 
15092     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSYS_ROOT_PATH" >&5
15093 $as_echo "$MSYS_ROOT_PATH" >&6; }
15094     WINDOWS_ENV_ROOT_PATH="$MSYS_ROOT_PATH"
15095   else
15096     as_fn_error $? "Unknown Windows environment. Neither cygwin nor msys was detected." "$LINENO" 5
15097   fi
15098 
15099   # Test if windows or unix (cygwin/msys) find is first in path.
15100   { $as_echo "$as_me:${as_lineno-$LINENO}: checking what kind of 'find' is first on the PATH" >&5
15101 $as_echo_n "checking what kind of 'find' is first on the PATH... " >&6; }
15102   FIND_BINARY_OUTPUT=`find --version 2>&1`
15103   if test "x`echo $FIND_BINARY_OUTPUT | $GREP GNU`" != x; then
15104     { $as_echo "$as_me:${as_lineno-$LINENO}: result: unix style" >&5
15105 $as_echo "unix style" >&6; }
15106   elif test "x`echo $FIND_BINARY_OUTPUT | $GREP FIND`" != x; then
15107     { $as_echo "$as_me:${as_lineno-$LINENO}: result: Windows" >&5
15108 $as_echo "Windows" >&6; }
15109     { $as_echo "$as_me:${as_lineno-$LINENO}: Your path contains Windows tools (C:\Windows\system32) before your unix (cygwin or msys) tools." >&5
15110 $as_echo "$as_me: Your path contains Windows tools (C:\Windows\system32) before your unix (cygwin or msys) tools." >&6;}
15111     { $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
15112 $as_echo "$as_me: This will not work. Please correct and make sure /usr/bin (or similar) is first in path." >&6;}
15113     as_fn_error $? "Cannot continue" "$LINENO" 5
15114   else
15115     { $as_echo "$as_me:${as_lineno-$LINENO}: result: unknown" >&5
15116 $as_echo "unknown" >&6; }
15117     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: It seems that your find utility is non-standard." >&5
15118 $as_echo "$as_me: WARNING: It seems that your find utility is non-standard." >&2;}
15119   fi
15120 
15121   else
15122     PATH_SEP=":"
15123   fi
15124 
15125 
15126   # We get the top-level directory from the supporting wrappers.
15127   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for top-level directory" >&5
15128 $as_echo_n "checking for top-level directory... " >&6; }
15129   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOPDIR" >&5
15130 $as_echo "$TOPDIR" >&6; }
15131 
15132 
15133   # Save the original version of TOPDIR for string comparisons
15134   ORIGINAL_TOPDIR="$TOPDIR"
15135 
15136 
15137   # We can only call BASIC_FIXUP_PATH after BASIC_CHECK_PATHS_WINDOWS.
15138 
15139   # Only process if variable expands to non-empty
15140 
15141   if test "x$CURDIR" != x; then
15142     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15143 
15144   # Input might be given as Windows format, start by converting to
15145   # unix format.
15146   path="$CURDIR"
15147   new_path=`$CYGPATH -u "$path"`
15148 
15149   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
15150   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
15151   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
15152   # "foo.exe" is OK but "foo" is an error.
15153   #
15154   # This test is therefore slightly more accurate than "test -f" to check for file precense.
15155   # It is also a way to make sure we got the proper file name for the real test later on.
15156   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
15157   if test "x$test_shortpath" = x; then
15158     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CURDIR, which resolves as \"$path\", is invalid." >&5
15159 $as_echo "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid." >&6;}
15160     as_fn_error $? "Cannot locate the the path of CURDIR" "$LINENO" 5
15161   fi
15162 
15163   # Call helper function which possibly converts this using DOS-style short mode.
15164   # If so, the updated path is stored in $new_path.
15165 
15166   input_path="$new_path"
15167   # Check if we need to convert this using DOS-style short mode. If the path
15168   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15169   # take no chances and rewrite it.
15170   # Note: m4 eats our [], so we need to use [ and ] instead.
15171   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
15172   if test "x$has_forbidden_chars" != x; then
15173     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15174     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
15175     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
15176     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
15177       # Going to short mode and back again did indeed matter. Since short mode is
15178       # case insensitive, let's make it lowercase to improve readability.
15179       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15180       # Now convert it back to Unix-style (cygpath)
15181       input_path=`$CYGPATH -u "$shortmode_path"`
15182       new_path="$input_path"
15183     fi
15184   fi
15185 
15186   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
15187   if test "x$test_cygdrive_prefix" = x; then
15188     # As a simple fix, exclude /usr/bin since it's not a real path.
15189     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
15190       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
15191       # a path prefixed by /cygdrive for fixpath to work.
15192       new_path="$CYGWIN_ROOT_PATH$input_path"
15193     fi
15194   fi
15195 
15196 
15197   if test "x$path" != "x$new_path"; then
15198     CURDIR="$new_path"
15199     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
15200 $as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
15201   fi
15202 
15203     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15204 
15205   path="$CURDIR"
15206   has_colon=`$ECHO $path | $GREP ^.:`
15207   new_path="$path"
15208   if test "x$has_colon" = x; then
15209     # Not in mixed or Windows style, start by that.
15210     new_path=`cmd //c echo $path`
15211   fi
15212 
15213 
15214   input_path="$new_path"
15215   # Check if we need to convert this using DOS-style short mode. If the path
15216   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15217   # take no chances and rewrite it.
15218   # Note: m4 eats our [], so we need to use [ and ] instead.
15219   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
15220   if test "x$has_forbidden_chars" != x; then
15221     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15222     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15223   fi
15224 
15225 
15226   windows_path="$new_path"
15227   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15228     unix_path=`$CYGPATH -u "$windows_path"`
15229     new_path="$unix_path"
15230   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15231     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15232     new_path="$unix_path"
15233   fi
15234 
15235   if test "x$path" != "x$new_path"; then
15236     CURDIR="$new_path"
15237     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
15238 $as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
15239   fi
15240 
15241   # Save the first 10 bytes of this path to the storage, so fixpath can work.
15242   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
15243 
15244     else
15245       # We're on a unix platform. Hooray! :)
15246       path="$CURDIR"
15247       has_space=`$ECHO "$path" | $GREP " "`
15248       if test "x$has_space" != x; then
15249         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CURDIR, which resolves as \"$path\", is invalid." >&5
15250 $as_echo "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid." >&6;}
15251         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
15252       fi
15253 
15254       # Use eval to expand a potential ~
15255       eval path="$path"
15256       if test ! -f "$path" && test ! -d "$path"; then
15257         as_fn_error $? "The path of CURDIR, which resolves as \"$path\", is not found." "$LINENO" 5
15258       fi
15259 
15260       CURDIR="`cd "$path"; $THEPWDCMD -L`"
15261     fi
15262   fi
15263 
15264 
15265   # Only process if variable expands to non-empty
15266 
15267   if test "x$TOPDIR" != x; then
15268     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15269 
15270   # Input might be given as Windows format, start by converting to
15271   # unix format.
15272   path="$TOPDIR"
15273   new_path=`$CYGPATH -u "$path"`
15274 
15275   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
15276   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
15277   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
15278   # "foo.exe" is OK but "foo" is an error.
15279   #
15280   # This test is therefore slightly more accurate than "test -f" to check for file precense.
15281   # It is also a way to make sure we got the proper file name for the real test later on.
15282   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
15283   if test "x$test_shortpath" = x; then
15284     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of TOPDIR, which resolves as \"$path\", is invalid." >&5
15285 $as_echo "$as_me: The path of TOPDIR, which resolves as \"$path\", is invalid." >&6;}
15286     as_fn_error $? "Cannot locate the the path of TOPDIR" "$LINENO" 5
15287   fi
15288 
15289   # Call helper function which possibly converts this using DOS-style short mode.
15290   # If so, the updated path is stored in $new_path.
15291 
15292   input_path="$new_path"
15293   # Check if we need to convert this using DOS-style short mode. If the path
15294   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15295   # take no chances and rewrite it.
15296   # Note: m4 eats our [], so we need to use [ and ] instead.
15297   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
15298   if test "x$has_forbidden_chars" != x; then
15299     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15300     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
15301     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
15302     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
15303       # Going to short mode and back again did indeed matter. Since short mode is
15304       # case insensitive, let's make it lowercase to improve readability.
15305       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15306       # Now convert it back to Unix-style (cygpath)
15307       input_path=`$CYGPATH -u "$shortmode_path"`
15308       new_path="$input_path"
15309     fi
15310   fi
15311 
15312   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
15313   if test "x$test_cygdrive_prefix" = x; then
15314     # As a simple fix, exclude /usr/bin since it's not a real path.
15315     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
15316       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
15317       # a path prefixed by /cygdrive for fixpath to work.
15318       new_path="$CYGWIN_ROOT_PATH$input_path"
15319     fi
15320   fi
15321 
15322 
15323   if test "x$path" != "x$new_path"; then
15324     TOPDIR="$new_path"
15325     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting TOPDIR to \"$new_path\"" >&5
15326 $as_echo "$as_me: Rewriting TOPDIR to \"$new_path\"" >&6;}
15327   fi
15328 
15329     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15330 
15331   path="$TOPDIR"
15332   has_colon=`$ECHO $path | $GREP ^.:`
15333   new_path="$path"
15334   if test "x$has_colon" = x; then
15335     # Not in mixed or Windows style, start by that.
15336     new_path=`cmd //c echo $path`
15337   fi
15338 
15339 
15340   input_path="$new_path"
15341   # Check if we need to convert this using DOS-style short mode. If the path
15342   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15343   # take no chances and rewrite it.
15344   # Note: m4 eats our [], so we need to use [ and ] instead.
15345   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
15346   if test "x$has_forbidden_chars" != x; then
15347     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15348     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15349   fi
15350 
15351 
15352   windows_path="$new_path"
15353   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15354     unix_path=`$CYGPATH -u "$windows_path"`
15355     new_path="$unix_path"
15356   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15357     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15358     new_path="$unix_path"
15359   fi
15360 
15361   if test "x$path" != "x$new_path"; then
15362     TOPDIR="$new_path"
15363     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting TOPDIR to \"$new_path\"" >&5
15364 $as_echo "$as_me: Rewriting TOPDIR to \"$new_path\"" >&6;}
15365   fi
15366 
15367   # Save the first 10 bytes of this path to the storage, so fixpath can work.
15368   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
15369 
15370     else
15371       # We're on a unix platform. Hooray! :)
15372       path="$TOPDIR"
15373       has_space=`$ECHO "$path" | $GREP " "`
15374       if test "x$has_space" != x; then
15375         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of TOPDIR, which resolves as \"$path\", is invalid." >&5
15376 $as_echo "$as_me: The path of TOPDIR, which resolves as \"$path\", is invalid." >&6;}
15377         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
15378       fi
15379 
15380       # Use eval to expand a potential ~
15381       eval path="$path"
15382       if test ! -f "$path" && test ! -d "$path"; then
15383         as_fn_error $? "The path of TOPDIR, which resolves as \"$path\", is not found." "$LINENO" 5
15384       fi
15385 
15386       TOPDIR="`cd "$path"; $THEPWDCMD -L`"
15387     fi
15388   fi
15389 
15390   # SRC_ROOT is a traditional alias for TOPDIR.
15391   SRC_ROOT=$TOPDIR
15392 
15393   # Calculate a canonical version of TOPDIR for string comparisons
15394   CANONICAL_TOPDIR=$TOPDIR
15395 
15396   if test "x$OPENJDK_BUILD_OS" != xwindows; then
15397     # Follow a chain of symbolic links. Use readlink
15398     # where it exists, else fall back to horribly
15399     # complicated shell code.
15400     if test "x$READLINK_TESTED" != yes; then
15401       # On MacOSX there is a readlink tool with a different
15402       # purpose than the GNU readlink tool. Check the found readlink.
15403       ISGNU=`$READLINK --version 2>&1 | $GREP GNU`
15404       if test "x$ISGNU" = x; then
15405         # A readlink that we do not know how to use.
15406         # Are there other non-GNU readlinks out there?
15407         READLINK_TESTED=yes
15408         READLINK=
15409       fi
15410     fi
15411 
15412     if test "x$READLINK" != x; then
15413       CANONICAL_TOPDIR=`$READLINK -f $CANONICAL_TOPDIR`
15414     else
15415       # Save the current directory for restoring afterwards
15416       STARTDIR=$PWD
15417       COUNTER=0
15418       sym_link_dir=`$DIRNAME $CANONICAL_TOPDIR`
15419       sym_link_file=`$BASENAME $CANONICAL_TOPDIR`
15420       cd $sym_link_dir
15421       # Use -P flag to resolve symlinks in directories.
15422       cd `$THEPWDCMD -P`
15423       sym_link_dir=`$THEPWDCMD -P`
15424       # Resolve file symlinks
15425       while test $COUNTER -lt 20; do
15426         ISLINK=`$LS -l $sym_link_dir/$sym_link_file | $GREP '\->' | $SED -e 's/.*-> \(.*\)/\1/'`
15427         if test "x$ISLINK" == x; then
15428           # This is not a symbolic link! We are done!
15429           break
15430         fi
15431         # Again resolve directory symlinks since the target of the just found
15432         # link could be in a different directory
15433         cd `$DIRNAME $ISLINK`
15434         sym_link_dir=`$THEPWDCMD -P`
15435         sym_link_file=`$BASENAME $ISLINK`
15436         let COUNTER=COUNTER+1
15437       done
15438       cd $STARTDIR
15439       CANONICAL_TOPDIR=$sym_link_dir/$sym_link_file
15440     fi
15441   fi
15442 
15443 
15444 
15445   # Locate the directory of this script.
15446   AUTOCONF_DIR=$TOPDIR/common/autoconf
15447 
15448 
15449 # Check if it's a pure open build or if custom sources are to be used.
15450 
15451   # Check whether --enable-openjdk-only was given.
15452 if test "${enable_openjdk_only+set}" = set; then :
15453   enableval=$enable_openjdk_only;
15454 else
15455   enable_openjdk_only="no"
15456 fi
15457 
15458 
15459   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for presence of closed sources" >&5
15460 $as_echo_n "checking for presence of closed sources... " >&6; }
15461   if test -d "$SRC_ROOT/jdk/src/closed"; then
15462     CLOSED_SOURCE_PRESENT=yes
15463   else
15464     CLOSED_SOURCE_PRESENT=no
15465   fi
15466   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CLOSED_SOURCE_PRESENT" >&5
15467 $as_echo "$CLOSED_SOURCE_PRESENT" >&6; }
15468 
15469   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if closed source is suppressed (openjdk-only)" >&5
15470 $as_echo_n "checking if closed source is suppressed (openjdk-only)... " >&6; }
15471   SUPPRESS_CLOSED_SOURCE="$enable_openjdk_only"
15472   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SUPPRESS_CLOSED_SOURCE" >&5
15473 $as_echo "$SUPPRESS_CLOSED_SOURCE" >&6; }
15474 
15475   if test "x$CLOSED_SOURCE_PRESENT" = xno; then
15476     OPENJDK=true
15477     if test "x$SUPPRESS_CLOSED_SOURCE" = "xyes"; then
15478       { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No closed source present, --enable-openjdk-only makes no sense" >&5
15479 $as_echo "$as_me: WARNING: No closed source present, --enable-openjdk-only makes no sense" >&2;}
15480     fi
15481   else
15482     if test "x$SUPPRESS_CLOSED_SOURCE" = "xyes"; then
15483       OPENJDK=true
15484     else
15485       OPENJDK=false
15486     fi
15487   fi
15488 
15489   if test "x$OPENJDK" = "xtrue"; then
15490     SET_OPENJDK="OPENJDK=true"
15491   fi
15492 
15493 
15494 
15495   # custom-make-dir is deprecated. Please use your custom-hook.m4 to override
15496   # the IncludeCustomExtension macro.
15497 
15498 
15499 # Check whether --with-custom-make-dir was given.
15500 if test "${with_custom_make_dir+set}" = set; then :
15501   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
15502 $as_echo "$as_me: WARNING: Option --with-custom-make-dir is deprecated and will be ignored." >&2;}
15503 fi
15504 
15505 
15506 
15507 
15508 # These are needed to be able to create a configuration name (and thus the output directory)
15509 
15510   ###############################################################################
15511   #
15512   # Check which variant of the JDK that we want to build.
15513   # Currently we have:
15514   #    normal:   standard edition
15515   # but the custom make system may add other variants
15516   #
15517   # Effectively the JDK variant gives a name to a specific set of
15518   # modules to compile into the JDK. In the future, these modules
15519   # might even be Jigsaw modules.
15520   #
15521   { $as_echo "$as_me:${as_lineno-$LINENO}: checking which variant of the JDK to build" >&5
15522 $as_echo_n "checking which variant of the JDK to build... " >&6; }
15523 
15524 # Check whether --with-jdk-variant was given.
15525 if test "${with_jdk_variant+set}" = set; then :
15526   withval=$with_jdk_variant;
15527 fi
15528 
15529 
15530   if test "x$with_jdk_variant" = xnormal || test "x$with_jdk_variant" = x; then
15531     JDK_VARIANT="normal"
15532   else
15533     as_fn_error $? "The available JDK variants are: normal" "$LINENO" 5
15534   fi
15535 
15536 
15537 
15538   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JDK_VARIANT" >&5
15539 $as_echo "$JDK_VARIANT" >&6; }
15540 
15541 
15542 ###############################################################################
15543 #
15544 # Check which interpreter of the JVM we want to build.
15545 # Currently we have:
15546 #    template: Template interpreter (the default)
15547 #    cpp     : C++ interpreter
15548 { $as_echo "$as_me:${as_lineno-$LINENO}: checking which interpreter of the JVM to build" >&5
15549 $as_echo_n "checking which interpreter of the JVM to build... " >&6; }
15550 
15551 # Check whether --with-jvm-interpreter was given.
15552 if test "${with_jvm_interpreter+set}" = set; then :
15553   withval=$with_jvm_interpreter;
15554 fi
15555 
15556 
15557 if test "x$with_jvm_interpreter" = x; then
15558      with_jvm_interpreter="template"
15559 fi
15560 
15561 JVM_INTERPRETER="$with_jvm_interpreter"
15562 
15563 if test "x$JVM_INTERPRETER" != xtemplate && test "x$JVM_INTERPRETER" != xcpp; then
15564    as_fn_error $? "The available JVM interpreters are: template, cpp" "$LINENO" 5
15565 fi
15566 
15567 
15568 
15569 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_jvm_interpreter" >&5
15570 $as_echo "$with_jvm_interpreter" >&6; }
15571 
15572 
15573 
15574   ###############################################################################
15575   #
15576   # Check which variants of the JVM that we want to build.
15577   # Currently we have:
15578   #    server: normal interpreter and a tiered C1/C2 compiler
15579   #    client: normal interpreter and C1 (no C2 compiler) (only 32-bit platforms)
15580   #    minimal1: reduced form of client with optional VM services and features stripped out
15581   #    kernel: kernel footprint JVM that passes the TCK without major performance problems,
15582   #             ie normal interpreter and C1, only the serial GC, kernel jvmti etc
15583   #    zero: no machine code interpreter, no compiler
15584   #    zeroshark: zero interpreter and shark/llvm compiler backend
15585 #    core: interpreter only, no compiler (only works on some platforms)
15586   { $as_echo "$as_me:${as_lineno-$LINENO}: checking which variants of the JVM to build" >&5
15587 $as_echo_n "checking which variants of the JVM to build... " >&6; }
15588 
15589 # Check whether --with-jvm-variants was given.
15590 if test "${with_jvm_variants+set}" = set; then :
15591   withval=$with_jvm_variants;
15592 fi
15593 
15594 
15595   if test "x$with_jvm_variants" = x; then
15596     with_jvm_variants="server"
15597   fi
15598 
15599   JVM_VARIANTS=",$with_jvm_variants,"
15600   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,//'`
15601 
15602   if test "x$TEST_VARIANTS" != "x,"; then
15603      as_fn_error $? "The available JVM variants are: server, client, minimal1, kernel, zero, zeroshark, core" "$LINENO" 5
15604   fi
15605   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_jvm_variants" >&5
15606 $as_echo "$with_jvm_variants" >&6; }
15607 
15608   JVM_VARIANT_SERVER=`$ECHO "$JVM_VARIANTS" | $SED -e '/,server,/!s/.*/false/g' -e '/,server,/s/.*/true/g'`
15609   JVM_VARIANT_CLIENT=`$ECHO "$JVM_VARIANTS" | $SED -e '/,client,/!s/.*/false/g' -e '/,client,/s/.*/true/g'`
15610   JVM_VARIANT_MINIMAL1=`$ECHO "$JVM_VARIANTS" | $SED -e '/,minimal1,/!s/.*/false/g' -e '/,minimal1,/s/.*/true/g'`
15611   JVM_VARIANT_KERNEL=`$ECHO "$JVM_VARIANTS" | $SED -e '/,kernel,/!s/.*/false/g' -e '/,kernel,/s/.*/true/g'`
15612   JVM_VARIANT_ZERO=`$ECHO "$JVM_VARIANTS" | $SED -e '/,zero,/!s/.*/false/g' -e '/,zero,/s/.*/true/g'`
15613   JVM_VARIANT_ZEROSHARK=`$ECHO "$JVM_VARIANTS" | $SED -e '/,zeroshark,/!s/.*/false/g' -e '/,zeroshark,/s/.*/true/g'`
15614   JVM_VARIANT_CORE=`$ECHO "$JVM_VARIANTS" | $SED -e '/,core,/!s/.*/false/g' -e '/,core,/s/.*/true/g'`
15615 
15616   if test "x$JVM_VARIANT_CLIENT" = xtrue; then
15617     if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
15618       as_fn_error $? "You cannot build a client JVM for a 64-bit machine." "$LINENO" 5
15619     fi
15620   fi
15621   if test "x$JVM_VARIANT_KERNEL" = xtrue; then
15622     if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
15623       as_fn_error $? "You cannot build a kernel JVM for a 64-bit machine." "$LINENO" 5
15624     fi
15625   fi
15626   if test "x$JVM_VARIANT_MINIMAL1" = xtrue; then
15627     if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
15628       as_fn_error $? "You cannot build a minimal JVM for a 64-bit machine." "$LINENO" 5
15629     fi
15630   fi
15631 
15632   # Replace the commas with AND for use in the build directory name.
15633   ANDED_JVM_VARIANTS=`$ECHO "$JVM_VARIANTS" | $SED -e 's/^,//' -e 's/,$//' -e 's/,/AND/g'`
15634   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/'`
15635   if test "x$COUNT_VARIANTS" != "x,1"; then
15636     BUILDING_MULTIPLE_JVM_VARIANTS=yes
15637   else
15638     BUILDING_MULTIPLE_JVM_VARIANTS=no
15639   fi
15640 
15641 
15642 
15643 
15644 
15645 
15646 
15647 
15648 
15649 
15650   INCLUDE_SA=true
15651   if test "x$JVM_VARIANT_ZERO" = xtrue ; then
15652     INCLUDE_SA=false
15653   fi
15654   if test "x$JVM_VARIANT_ZEROSHARK" = xtrue ; then
15655     INCLUDE_SA=false
15656   fi
15657   if test "x$OPENJDK_TARGET_OS" = xaix ; then
15658     INCLUDE_SA=false
15659   fi
15660   if test "x$OPENJDK_TARGET_CPU" = xaarch64; then
15661     INCLUDE_SA=false
15662   fi
15663 
15664 
15665   if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
15666     MACOSX_UNIVERSAL="true"
15667   fi
15668 
15669 
15670 
15671 
15672   ###############################################################################
15673   #
15674   # Set the debug level
15675   #    release: no debug information, all optimizations, no asserts.
15676   #    optimized: no debug information, all optimizations, no asserts, HotSpot target is 'optimized'.
15677   #    fastdebug: debug information (-g), all optimizations, all asserts
15678   #    slowdebug: debug information (-g), no optimizations, all asserts
15679   #
15680   DEBUG_LEVEL="release"
15681   { $as_echo "$as_me:${as_lineno-$LINENO}: checking which debug level to use" >&5
15682 $as_echo_n "checking which debug level to use... " >&6; }
15683   # Check whether --enable-debug was given.
15684 if test "${enable_debug+set}" = set; then :
15685   enableval=$enable_debug;
15686         ENABLE_DEBUG="${enableval}"
15687         DEBUG_LEVEL="fastdebug"
15688 
15689 else
15690   ENABLE_DEBUG="no"
15691 fi
15692 
15693 
15694 
15695 # Check whether --with-debug-level was given.
15696 if test "${with_debug_level+set}" = set; then :
15697   withval=$with_debug_level;
15698         DEBUG_LEVEL="${withval}"
15699         if test "x$ENABLE_DEBUG" = xyes; then
15700           as_fn_error $? "You cannot use both --enable-debug and --with-debug-level at the same time." "$LINENO" 5
15701         fi
15702 
15703 fi
15704 
15705   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEBUG_LEVEL" >&5
15706 $as_echo "$DEBUG_LEVEL" >&6; }
15707 
15708   if test "x$DEBUG_LEVEL" != xrelease && \
15709       test "x$DEBUG_LEVEL" != xoptimized && \
15710       test "x$DEBUG_LEVEL" != xfastdebug && \
15711       test "x$DEBUG_LEVEL" != xslowdebug; then
15712     as_fn_error $? "Allowed debug levels are: release, fastdebug and slowdebug" "$LINENO" 5
15713   fi
15714 
15715 
15716   ###############################################################################
15717   #
15718   # Setup legacy vars/targets and new vars to deal with different debug levels.
15719   #
15720 
15721   case $DEBUG_LEVEL in
15722     release )
15723       VARIANT="OPT"
15724       FASTDEBUG="false"
15725       DEBUG_CLASSFILES="false"
15726       BUILD_VARIANT_RELEASE=""
15727       HOTSPOT_DEBUG_LEVEL="product"
15728       HOTSPOT_EXPORT="product"
15729       ;;
15730     fastdebug )
15731       VARIANT="DBG"
15732       FASTDEBUG="true"
15733       DEBUG_CLASSFILES="true"
15734       BUILD_VARIANT_RELEASE="-fastdebug"
15735       HOTSPOT_DEBUG_LEVEL="fastdebug"
15736       HOTSPOT_EXPORT="fastdebug"
15737       ;;
15738     slowdebug )
15739       VARIANT="DBG"
15740       FASTDEBUG="false"
15741       DEBUG_CLASSFILES="true"
15742       BUILD_VARIANT_RELEASE="-debug"
15743       HOTSPOT_DEBUG_LEVEL="debug"
15744       HOTSPOT_EXPORT="debug"
15745       ;;
15746     optimized )
15747       VARIANT="OPT"
15748       FASTDEBUG="false"
15749       DEBUG_CLASSFILES="false"
15750       BUILD_VARIANT_RELEASE="-optimized"
15751       HOTSPOT_DEBUG_LEVEL="optimized"
15752       HOTSPOT_EXPORT="optimized"
15753       ;;
15754   esac
15755 
15756   # The debug level 'optimized' is a little special because it is currently only
15757   # applicable to the HotSpot build where it means to build a completely
15758   # optimized version of the VM without any debugging code (like for the
15759   # 'release' debug level which is called 'product' in the HotSpot build) but
15760   # with the exception that it can contain additional code which is otherwise
15761   # protected by '#ifndef PRODUCT' macros. These 'optimized' builds are used to
15762   # test new and/or experimental features which are not intended for customer
15763   # shipment. Because these new features need to be tested and benchmarked in
15764   # real world scenarios, we want to build the containing JDK at the 'release'
15765   # debug level.
15766   if test "x$DEBUG_LEVEL" = xoptimized; then
15767     DEBUG_LEVEL="release"
15768   fi
15769 
15770   #####
15771   # Generate the legacy makefile targets for hotspot.
15772   # The hotspot api for selecting the build artifacts, really, needs to be improved.
15773   # JDK-7195896 will fix this on the hotspot side by using the JVM_VARIANT_* variables to
15774   # determine what needs to be built. All we will need to set here is all_product, all_fastdebug etc
15775   # But until then ...
15776   HOTSPOT_TARGET=""
15777 
15778   if test "x$JVM_VARIANT_SERVER" = xtrue; then
15779     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL} "
15780   fi
15781 
15782   if test "x$JVM_VARIANT_CLIENT" = xtrue; then
15783     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}1 "
15784   fi
15785 
15786   if test "x$JVM_VARIANT_MINIMAL1" = xtrue; then
15787     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}minimal1 "
15788   fi
15789 
15790   if test "x$JVM_VARIANT_KERNEL" = xtrue; then
15791     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}kernel "
15792   fi
15793 
15794   if test "x$JVM_VARIANT_ZERO" = xtrue; then
15795     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}zero "
15796   fi
15797 
15798   if test "x$JVM_VARIANT_ZEROSHARK" = xtrue; then
15799     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}shark "
15800   fi
15801 
15802   if test "x$JVM_VARIANT_CORE" = xtrue; then
15803     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}core "
15804   fi
15805 
15806   HOTSPOT_TARGET="$HOTSPOT_TARGET docs export_$HOTSPOT_EXPORT"
15807 
15808   # On Macosx universal binaries are produced, but they only contain
15809   # 64 bit intel. This invalidates control of which jvms are built
15810   # from configure, but only server is valid anyway. Fix this
15811   # when hotspot makefiles are rewritten.
15812   if test "x$MACOSX_UNIVERSAL" = xtrue; then
15813     HOTSPOT_TARGET=universal_${HOTSPOT_EXPORT}
15814   fi
15815 
15816   #####
15817 
15818 
15819 
15820 
15821 
15822 
15823 
15824 
15825 # With basic setup done, call the custom early hook.
15826 
15827 
15828 # Check if we have devkits, extra paths or sysroot set.
15829 
15830 
15831 # Check whether --with-devkit was given.
15832 if test "${with_devkit+set}" = set; then :
15833   withval=$with_devkit;
15834 
15835   # Only process if variable expands to non-empty
15836 
15837   if test "x$with_devkit" != x; then
15838     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15839 
15840   # Input might be given as Windows format, start by converting to
15841   # unix format.
15842   path="$with_devkit"
15843   new_path=`$CYGPATH -u "$path"`
15844 
15845   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
15846   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
15847   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
15848   # "foo.exe" is OK but "foo" is an error.
15849   #
15850   # This test is therefore slightly more accurate than "test -f" to check for file precense.
15851   # It is also a way to make sure we got the proper file name for the real test later on.
15852   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
15853   if test "x$test_shortpath" = x; then
15854     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
15855 $as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
15856     as_fn_error $? "Cannot locate the the path of with_devkit" "$LINENO" 5
15857   fi
15858 
15859   # Call helper function which possibly converts this using DOS-style short mode.
15860   # If so, the updated path is stored in $new_path.
15861 
15862   input_path="$new_path"
15863   # Check if we need to convert this using DOS-style short mode. If the path
15864   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15865   # take no chances and rewrite it.
15866   # Note: m4 eats our [], so we need to use [ and ] instead.
15867   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
15868   if test "x$has_forbidden_chars" != x; then
15869     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15870     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
15871     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
15872     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
15873       # Going to short mode and back again did indeed matter. Since short mode is
15874       # case insensitive, let's make it lowercase to improve readability.
15875       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15876       # Now convert it back to Unix-style (cygpath)
15877       input_path=`$CYGPATH -u "$shortmode_path"`
15878       new_path="$input_path"
15879     fi
15880   fi
15881 
15882   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
15883   if test "x$test_cygdrive_prefix" = x; then
15884     # As a simple fix, exclude /usr/bin since it's not a real path.
15885     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
15886       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
15887       # a path prefixed by /cygdrive for fixpath to work.
15888       new_path="$CYGWIN_ROOT_PATH$input_path"
15889     fi
15890   fi
15891 
15892 
15893   if test "x$path" != "x$new_path"; then
15894     with_devkit="$new_path"
15895     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
15896 $as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
15897   fi
15898 
15899     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15900 
15901   path="$with_devkit"
15902   has_colon=`$ECHO $path | $GREP ^.:`
15903   new_path="$path"
15904   if test "x$has_colon" = x; then
15905     # Not in mixed or Windows style, start by that.
15906     new_path=`cmd //c echo $path`
15907   fi
15908 
15909 
15910   input_path="$new_path"
15911   # Check if we need to convert this using DOS-style short mode. If the path
15912   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15913   # take no chances and rewrite it.
15914   # Note: m4 eats our [], so we need to use [ and ] instead.
15915   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
15916   if test "x$has_forbidden_chars" != x; then
15917     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15918     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15919   fi
15920 
15921 
15922   windows_path="$new_path"
15923   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15924     unix_path=`$CYGPATH -u "$windows_path"`
15925     new_path="$unix_path"
15926   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15927     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15928     new_path="$unix_path"
15929   fi
15930 
15931   if test "x$path" != "x$new_path"; then
15932     with_devkit="$new_path"
15933     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
15934 $as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
15935   fi
15936 
15937   # Save the first 10 bytes of this path to the storage, so fixpath can work.
15938   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
15939 
15940     else
15941       # We're on a unix platform. Hooray! :)
15942       path="$with_devkit"
15943       has_space=`$ECHO "$path" | $GREP " "`
15944       if test "x$has_space" != x; then
15945         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
15946 $as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
15947         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
15948       fi
15949 
15950       # Use eval to expand a potential ~
15951       eval path="$path"
15952       if test ! -f "$path" && test ! -d "$path"; then
15953         as_fn_error $? "The path of with_devkit, which resolves as \"$path\", is not found." "$LINENO" 5
15954       fi
15955 
15956       with_devkit="`cd "$path"; $THEPWDCMD -L`"
15957     fi
15958   fi
15959 
15960         DEVKIT_ROOT="$with_devkit"
15961         # Check for a meta data info file in the root of the devkit
15962         if test -f "$DEVKIT_ROOT/devkit.info"; then
15963           . $DEVKIT_ROOT/devkit.info
15964           # This potentially sets the following:
15965           # A descriptive name of the devkit
15966 
15967   if test "x$DEVKIT_NAME" = x; then
15968     eval DEVKIT_NAME="\${DEVKIT_NAME_${OPENJDK_TARGET_CPU}}"
15969   fi
15970 
15971           # Corresponds to --with-extra-path
15972 
15973   if test "x$DEVKIT_EXTRA_PATH" = x; then
15974     eval DEVKIT_EXTRA_PATH="\${DEVKIT_EXTRA_PATH_${OPENJDK_TARGET_CPU}}"
15975   fi
15976 
15977           # Corresponds to --with-toolchain-path
15978 
15979   if test "x$DEVKIT_TOOLCHAIN_PATH" = x; then
15980     eval DEVKIT_TOOLCHAIN_PATH="\${DEVKIT_TOOLCHAIN_PATH_${OPENJDK_TARGET_CPU}}"
15981   fi
15982 
15983           # Corresponds to --with-sysroot
15984 
15985   if test "x$DEVKIT_SYSROOT" = x; then
15986     eval DEVKIT_SYSROOT="\${DEVKIT_SYSROOT_${OPENJDK_TARGET_CPU}}"
15987   fi
15988 
15989 
15990           # Identifies the Visual Studio version in the devkit
15991 
15992   if test "x$DEVKIT_VS_VERSION" = x; then
15993     eval DEVKIT_VS_VERSION="\${DEVKIT_VS_VERSION_${OPENJDK_TARGET_CPU}}"
15994   fi
15995 
15996           # The Visual Studio include environment variable
15997 
15998   if test "x$DEVKIT_VS_INCLUDE" = x; then
15999     eval DEVKIT_VS_INCLUDE="\${DEVKIT_VS_INCLUDE_${OPENJDK_TARGET_CPU}}"
16000   fi
16001 
16002           # The Visual Studio lib environment variable
16003 
16004   if test "x$DEVKIT_VS_LIB" = x; then
16005     eval DEVKIT_VS_LIB="\${DEVKIT_VS_LIB_${OPENJDK_TARGET_CPU}}"
16006   fi
16007 
16008           # Corresponds to --with-msvcr-dll
16009 
16010   if test "x$DEVKIT_MSVCR_DLL" = x; then
16011     eval DEVKIT_MSVCR_DLL="\${DEVKIT_MSVCR_DLL_${OPENJDK_TARGET_CPU}}"
16012   fi
16013 
16014           # Corresponds to --with-msvcp-dll
16015 
16016   if test "x$DEVKIT_MSVCP_DLL" = x; then
16017     eval DEVKIT_MSVCP_DLL="\${DEVKIT_MSVCP_DLL_${OPENJDK_TARGET_CPU}}"
16018   fi
16019 
16020         fi
16021 
16022         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for devkit" >&5
16023 $as_echo_n "checking for devkit... " >&6; }
16024         if test "x$DEVKIT_NAME" != x; then
16025           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEVKIT_NAME in $DEVKIT_ROOT" >&5
16026 $as_echo "$DEVKIT_NAME in $DEVKIT_ROOT" >&6; }
16027         else
16028           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEVKIT_ROOT" >&5
16029 $as_echo "$DEVKIT_ROOT" >&6; }
16030         fi
16031 
16032 
16033   if test "x$DEVKIT_EXTRA_PATH" != x; then
16034     if test "x$EXTRA_PATH" = x; then
16035       EXTRA_PATH="$DEVKIT_EXTRA_PATH"
16036     else
16037       EXTRA_PATH="$DEVKIT_EXTRA_PATH:$EXTRA_PATH"
16038     fi
16039   fi
16040 
16041 
16042         # Fallback default of just /bin if DEVKIT_PATH is not defined
16043         if test "x$DEVKIT_TOOLCHAIN_PATH" = x; then
16044           DEVKIT_TOOLCHAIN_PATH="$DEVKIT_ROOT/bin"
16045         fi
16046 
16047   if test "x$DEVKIT_TOOLCHAIN_PATH" != x; then
16048     if test "x$TOOLCHAIN_PATH" = x; then
16049       TOOLCHAIN_PATH="$DEVKIT_TOOLCHAIN_PATH"
16050     else
16051       TOOLCHAIN_PATH="$DEVKIT_TOOLCHAIN_PATH:$TOOLCHAIN_PATH"
16052     fi
16053   fi
16054 
16055 
16056         # If DEVKIT_SYSROOT is set, use that, otherwise try a couple of known
16057         # places for backwards compatiblity.
16058         if test "x$DEVKIT_SYSROOT" != x; then
16059           SYSROOT="$DEVKIT_SYSROOT"
16060         elif test -d "$DEVKIT_ROOT/$host_alias/libc"; then
16061           SYSROOT="$DEVKIT_ROOT/$host_alias/libc"
16062         elif test -d "$DEVKIT_ROOT/$host/sys-root"; then
16063           SYSROOT="$DEVKIT_ROOT/$host/sys-root"
16064         fi
16065 
16066 
16067 fi
16068 
16069 
16070   # You can force the sysroot if the sysroot encoded into the compiler tools
16071   # is not correct.
16072 
16073 # Check whether --with-sys-root was given.
16074 if test "${with_sys_root+set}" = set; then :
16075   withval=$with_sys_root; SYSROOT=$with_sys_root
16076 
16077 fi
16078 
16079 
16080 
16081 # Check whether --with-sysroot was given.
16082 if test "${with_sysroot+set}" = set; then :
16083   withval=$with_sysroot; SYSROOT=$with_sysroot
16084 
16085 fi
16086 
16087 
16088 
16089 # Check whether --with-tools-dir was given.
16090 if test "${with_tools_dir+set}" = set; then :
16091   withval=$with_tools_dir;
16092   if test "x$with_tools_dir" != x; then
16093     if test "x$TOOLCHAIN_PATH" = x; then
16094       TOOLCHAIN_PATH="$with_tools_dir"
16095     else
16096       TOOLCHAIN_PATH="$with_tools_dir:$TOOLCHAIN_PATH"
16097     fi
16098   fi
16099 
16100 
16101 fi
16102 
16103 
16104 
16105 # Check whether --with-toolchain-path was given.
16106 if test "${with_toolchain_path+set}" = set; then :
16107   withval=$with_toolchain_path;
16108   if test "x$with_toolchain_path" != x; then
16109     if test "x$TOOLCHAIN_PATH" = x; then
16110       TOOLCHAIN_PATH="$with_toolchain_path"
16111     else
16112       TOOLCHAIN_PATH="$with_toolchain_path:$TOOLCHAIN_PATH"
16113     fi
16114   fi
16115 
16116 
16117 fi
16118 
16119 
16120 
16121 # Check whether --with-extra-path was given.
16122 if test "${with_extra_path+set}" = set; then :
16123   withval=$with_extra_path;
16124   if test "x$with_extra_path" != x; then
16125     if test "x$EXTRA_PATH" = x; then
16126       EXTRA_PATH="$with_extra_path"
16127     else
16128       EXTRA_PATH="$with_extra_path:$EXTRA_PATH"
16129     fi
16130   fi
16131 
16132 
16133 fi
16134 
16135 
16136   if test "x$OPENJDK_BUILD_OS" = "xmacosx"; then
16137     # If a devkit has been supplied, find xcodebuild in the toolchain_path.
16138     # If not, detect if Xcode is installed by running xcodebuild -version
16139     # if no Xcode installed, xcodebuild exits with 1
16140     # if Xcode is installed, even if xcode-select is misconfigured, then it exits with 0
16141     if test "x$DEVKIT_ROOT" != x || /usr/bin/xcodebuild -version >/dev/null 2>&1; then
16142       # We need to use xcodebuild in the toolchain dir provided by the user, this will
16143       # fall back on the stub binary in /usr/bin/xcodebuild
16144       # Extract the first word of "xcodebuild", so it can be a program name with args.
16145 set dummy xcodebuild; ac_word=$2
16146 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
16147 $as_echo_n "checking for $ac_word... " >&6; }
16148 if ${ac_cv_path_XCODEBUILD+:} false; then :
16149   $as_echo_n "(cached) " >&6
16150 else
16151   case $XCODEBUILD in
16152   [\\/]* | ?:[\\/]*)
16153   ac_cv_path_XCODEBUILD="$XCODEBUILD" # Let the user override the test with a path.
16154   ;;
16155   *)
16156   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
16157 for as_dir in $TOOLCHAIN_PATH
16158 do
16159   IFS=$as_save_IFS
16160   test -z "$as_dir" && as_dir=.
16161     for ac_exec_ext in '' $ac_executable_extensions; do
16162   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
16163     ac_cv_path_XCODEBUILD="$as_dir/$ac_word$ac_exec_ext"
16164     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
16165     break 2
16166   fi
16167 done
16168   done
16169 IFS=$as_save_IFS
16170 
16171   test -z "$ac_cv_path_XCODEBUILD" && ac_cv_path_XCODEBUILD="/usr/bin/xcodebuild"
16172   ;;
16173 esac
16174 fi
16175 XCODEBUILD=$ac_cv_path_XCODEBUILD
16176 if test -n "$XCODEBUILD"; then
16177   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XCODEBUILD" >&5
16178 $as_echo "$XCODEBUILD" >&6; }
16179 else
16180   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
16181 $as_echo "no" >&6; }
16182 fi
16183 
16184 
16185     else
16186       # this should result in SYSROOT being empty, unless --with-sysroot is provided
16187       # when only the command line tools are installed there are no SDKs, so headers
16188       # are copied into the system frameworks
16189       XCODEBUILD=
16190 
16191     fi
16192 
16193     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for sdk name" >&5
16194 $as_echo_n "checking for sdk name... " >&6; }
16195 
16196 # Check whether --with-sdk-name was given.
16197 if test "${with_sdk_name+set}" = set; then :
16198   withval=$with_sdk_name; SDKNAME=$with_sdk_name
16199 
16200 fi
16201 
16202     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SDKNAME" >&5
16203 $as_echo "$SDKNAME" >&6; }
16204 
16205     # if toolchain path is specified then don't rely on system headers, they may not compile
16206     HAVE_SYSTEM_FRAMEWORK_HEADERS=0
16207     test -z "$TOOLCHAIN_PATH" && \
16208       HAVE_SYSTEM_FRAMEWORK_HEADERS=`test ! -f /System/Library/Frameworks/Foundation.framework/Headers/Foundation.h; echo $?`
16209 
16210     if test -z "$SYSROOT"; then
16211       if test -n "$XCODEBUILD"; then
16212         # if we don't have system headers, use default SDK name (last resort)
16213         if test -z "$SDKNAME" -a $HAVE_SYSTEM_FRAMEWORK_HEADERS -eq 0; then
16214           SDKNAME=${SDKNAME:-macosx}
16215         fi
16216 
16217         if test -n "$SDKNAME"; then
16218           # Call xcodebuild to determine SYSROOT
16219           SYSROOT=`"$XCODEBUILD" -sdk $SDKNAME -version | grep '^Path: ' | sed 's/Path: //'`
16220         fi
16221       else
16222         if test $HAVE_SYSTEM_FRAMEWORK_HEADERS -eq 0; then
16223           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
16224         fi
16225       fi
16226     else
16227       # warn user if --with-sdk-name was also set
16228       if test -n "$with_sdk_name"; then
16229         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Both SYSROOT and --with-sdk-name are set, only SYSROOT will be used" >&5
16230 $as_echo "$as_me: WARNING: Both SYSROOT and --with-sdk-name are set, only SYSROOT will be used" >&2;}
16231       fi
16232     fi
16233 
16234     if test $HAVE_SYSTEM_FRAMEWORK_HEADERS -eq 0 -a -z "$SYSROOT"; then
16235       # If no system framework headers, then SYSROOT must be set, or we won't build
16236       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
16237     fi
16238 
16239     # Perform a basic sanity test
16240     if test ! -f "$SYSROOT/System/Library/Frameworks/Foundation.framework/Headers/Foundation.h"; then
16241       if test -z "$SYSROOT"; then
16242         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
16243       else
16244         as_fn_error $? "Invalid SDK or SYSROOT path, dependent framework headers not found" "$LINENO" 5
16245       fi
16246     fi
16247 
16248     # set SDKROOT too, Xcode tools will pick it up
16249     SDKROOT=$SYSROOT
16250 
16251   fi
16252 
16253   # Prepend the extra path to the global path
16254 
16255   if test "x$EXTRA_PATH" != x; then
16256     if test "x$PATH" = x; then
16257       PATH="$EXTRA_PATH"
16258     else
16259       PATH="$EXTRA_PATH:$PATH"
16260     fi
16261   fi
16262 
16263 
16264   if test "x$OPENJDK_BUILD_OS" = "xsolaris"; then
16265     # Add extra search paths on solaris for utilities like ar and as etc...
16266     PATH="$PATH:/usr/ccs/bin:/usr/sfw/bin:/opt/csw/bin"
16267   fi
16268 
16269   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for sysroot" >&5
16270 $as_echo_n "checking for sysroot... " >&6; }
16271   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SYSROOT" >&5
16272 $as_echo "$SYSROOT" >&6; }
16273   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for toolchain path" >&5
16274 $as_echo_n "checking for toolchain path... " >&6; }
16275   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOOLCHAIN_PATH" >&5
16276 $as_echo "$TOOLCHAIN_PATH" >&6; }
16277   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for extra path" >&5
16278 $as_echo_n "checking for extra path... " >&6; }
16279   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXTRA_PATH" >&5
16280 $as_echo "$EXTRA_PATH" >&6; }
16281 
16282 
16283 # To properly create a configuration name, we need to have the OpenJDK target
16284 # and options (variants and debug level) parsed.
16285 
16286 
16287 
16288 # Check whether --with-conf-name was given.
16289 if test "${with_conf_name+set}" = set; then :
16290   withval=$with_conf_name;  CONF_NAME=${with_conf_name}
16291 fi
16292 
16293 
16294   # Test from where we are running configure, in or outside of src root.
16295   { $as_echo "$as_me:${as_lineno-$LINENO}: checking where to store configuration" >&5
16296 $as_echo_n "checking where to store configuration... " >&6; }
16297   if test "x$CURDIR" = "x$SRC_ROOT" || test "x$CURDIR" = "x$SRC_ROOT/common" \
16298       || test "x$CURDIR" = "x$SRC_ROOT/common/autoconf" \
16299       || test "x$CURDIR" = "x$SRC_ROOT/make" ; then
16300     # We are running configure from the src root.
16301     # Create a default ./build/target-variant-debuglevel output root.
16302     if test "x${CONF_NAME}" = x; then
16303       { $as_echo "$as_me:${as_lineno-$LINENO}: result: in default location" >&5
16304 $as_echo "in default location" >&6; }
16305       CONF_NAME="${OPENJDK_TARGET_OS}-${OPENJDK_TARGET_CPU}-${JDK_VARIANT}-${ANDED_JVM_VARIANTS}-${DEBUG_LEVEL}"
16306     else
16307       { $as_echo "$as_me:${as_lineno-$LINENO}: result: in build directory with custom name" >&5
16308 $as_echo "in build directory with custom name" >&6; }
16309     fi
16310     OUTPUT_ROOT="$SRC_ROOT/build/${CONF_NAME}"
16311     $MKDIR -p "$OUTPUT_ROOT"
16312     if test ! -d "$OUTPUT_ROOT"; then
16313       as_fn_error $? "Could not create build directory $OUTPUT_ROOT" "$LINENO" 5
16314     fi
16315   else
16316     # We are running configure from outside of the src dir.
16317     # Then use the current directory as output dir!
16318     # If configuration is situated in normal build directory, just use the build
16319     # directory name as configuration name, otherwise use the complete path.
16320     if test "x${CONF_NAME}" = x; then
16321       CONF_NAME=`$ECHO $CURDIR | $SED -e "s!^${SRC_ROOT}/build/!!"`
16322     fi
16323     OUTPUT_ROOT="$CURDIR"
16324     { $as_echo "$as_me:${as_lineno-$LINENO}: result: in current directory" >&5
16325 $as_echo "in current directory" >&6; }
16326 
16327     # WARNING: This might be a bad thing to do. You need to be sure you want to
16328     # have a configuration in this directory. Do some sanity checks!
16329 
16330     if test ! -e "$OUTPUT_ROOT/spec.gmk"; then
16331       # If we have a spec.gmk, we have run here before and we are OK. Otherwise, check for
16332       # other files
16333       files_present=`$LS $OUTPUT_ROOT`
16334       # Configure has already touched config.log and confdefs.h in the current dir when this check
16335       # is performed.
16336       filtered_files=`$ECHO "$files_present" \
16337           | $SED -e 's/config.log//g' \
16338               -e 's/configure.log//g' \
16339               -e 's/confdefs.h//g' \
16340               -e 's/ //g' \
16341           | $TR -d '\n'`
16342       if test "x$filtered_files" != x; then
16343         { $as_echo "$as_me:${as_lineno-$LINENO}: Current directory is $CURDIR." >&5
16344 $as_echo "$as_me: Current directory is $CURDIR." >&6;}
16345         { $as_echo "$as_me:${as_lineno-$LINENO}: Since this is not the source root, configure will output the configuration here" >&5
16346 $as_echo "$as_me: Since this is not the source root, configure will output the configuration here" >&6;}
16347         { $as_echo "$as_me:${as_lineno-$LINENO}: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&5
16348 $as_echo "$as_me: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&6;}
16349         { $as_echo "$as_me:${as_lineno-$LINENO}: However, this directory is not empty. This is not allowed, since it could" >&5
16350 $as_echo "$as_me: However, this directory is not empty. This is not allowed, since it could" >&6;}
16351         { $as_echo "$as_me:${as_lineno-$LINENO}: seriously mess up just about everything." >&5
16352 $as_echo "$as_me: seriously mess up just about everything." >&6;}
16353         { $as_echo "$as_me:${as_lineno-$LINENO}: Try 'cd $SRC_ROOT' and restart configure" >&5
16354 $as_echo "$as_me: Try 'cd $SRC_ROOT' and restart configure" >&6;}
16355         { $as_echo "$as_me:${as_lineno-$LINENO}: (or create a new empty directory and cd to it)." >&5
16356 $as_echo "$as_me: (or create a new empty directory and cd to it)." >&6;}
16357         as_fn_error $? "Will not continue creating configuration in $CURDIR" "$LINENO" 5
16358       fi
16359     fi
16360   fi
16361   { $as_echo "$as_me:${as_lineno-$LINENO}: checking what configuration name to use" >&5
16362 $as_echo_n "checking what configuration name to use... " >&6; }
16363   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CONF_NAME" >&5
16364 $as_echo "$CONF_NAME" >&6; }
16365 
16366 
16367   # Only process if variable expands to non-empty
16368 
16369   if test "x$OUTPUT_ROOT" != x; then
16370     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16371 
16372   # Input might be given as Windows format, start by converting to
16373   # unix format.
16374   path="$OUTPUT_ROOT"
16375   new_path=`$CYGPATH -u "$path"`
16376 
16377   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
16378   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
16379   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
16380   # "foo.exe" is OK but "foo" is an error.
16381   #
16382   # This test is therefore slightly more accurate than "test -f" to check for file precense.
16383   # It is also a way to make sure we got the proper file name for the real test later on.
16384   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
16385   if test "x$test_shortpath" = x; then
16386     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&5
16387 $as_echo "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&6;}
16388     as_fn_error $? "Cannot locate the the path of OUTPUT_ROOT" "$LINENO" 5
16389   fi
16390 
16391   # Call helper function which possibly converts this using DOS-style short mode.
16392   # If so, the updated path is stored in $new_path.
16393 
16394   input_path="$new_path"
16395   # Check if we need to convert this using DOS-style short mode. If the path
16396   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16397   # take no chances and rewrite it.
16398   # Note: m4 eats our [], so we need to use [ and ] instead.
16399   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
16400   if test "x$has_forbidden_chars" != x; then
16401     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16402     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
16403     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
16404     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
16405       # Going to short mode and back again did indeed matter. Since short mode is
16406       # case insensitive, let's make it lowercase to improve readability.
16407       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16408       # Now convert it back to Unix-style (cygpath)
16409       input_path=`$CYGPATH -u "$shortmode_path"`
16410       new_path="$input_path"
16411     fi
16412   fi
16413 
16414   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
16415   if test "x$test_cygdrive_prefix" = x; then
16416     # As a simple fix, exclude /usr/bin since it's not a real path.
16417     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
16418       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
16419       # a path prefixed by /cygdrive for fixpath to work.
16420       new_path="$CYGWIN_ROOT_PATH$input_path"
16421     fi
16422   fi
16423 
16424 
16425   if test "x$path" != "x$new_path"; then
16426     OUTPUT_ROOT="$new_path"
16427     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
16428 $as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
16429   fi
16430 
16431     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16432 
16433   path="$OUTPUT_ROOT"
16434   has_colon=`$ECHO $path | $GREP ^.:`
16435   new_path="$path"
16436   if test "x$has_colon" = x; then
16437     # Not in mixed or Windows style, start by that.
16438     new_path=`cmd //c echo $path`
16439   fi
16440 
16441 
16442   input_path="$new_path"
16443   # Check if we need to convert this using DOS-style short mode. If the path
16444   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16445   # take no chances and rewrite it.
16446   # Note: m4 eats our [], so we need to use [ and ] instead.
16447   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
16448   if test "x$has_forbidden_chars" != x; then
16449     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16450     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16451   fi
16452 
16453 
16454   windows_path="$new_path"
16455   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16456     unix_path=`$CYGPATH -u "$windows_path"`
16457     new_path="$unix_path"
16458   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16459     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16460     new_path="$unix_path"
16461   fi
16462 
16463   if test "x$path" != "x$new_path"; then
16464     OUTPUT_ROOT="$new_path"
16465     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
16466 $as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
16467   fi
16468 
16469   # Save the first 10 bytes of this path to the storage, so fixpath can work.
16470   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
16471 
16472     else
16473       # We're on a unix platform. Hooray! :)
16474       path="$OUTPUT_ROOT"
16475       has_space=`$ECHO "$path" | $GREP " "`
16476       if test "x$has_space" != x; then
16477         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&5
16478 $as_echo "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&6;}
16479         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
16480       fi
16481 
16482       # Use eval to expand a potential ~
16483       eval path="$path"
16484       if test ! -f "$path" && test ! -d "$path"; then
16485         as_fn_error $? "The path of OUTPUT_ROOT, which resolves as \"$path\", is not found." "$LINENO" 5
16486       fi
16487 
16488       OUTPUT_ROOT="`cd "$path"; $THEPWDCMD -L`"
16489     fi
16490   fi
16491 
16492 
16493   CONFIGURESUPPORT_OUTPUTDIR="$OUTPUT_ROOT/configure-support"
16494   $MKDIR -p "$CONFIGURESUPPORT_OUTPUTDIR"
16495 
16496   SPEC=$OUTPUT_ROOT/spec.gmk
16497 
16498   CONF_NAME=$CONF_NAME
16499 
16500   OUTPUT_ROOT=$OUTPUT_ROOT
16501 
16502 
16503 
16504   # The spec.gmk file contains all variables for the make system.
16505   ac_config_files="$ac_config_files $OUTPUT_ROOT/spec.gmk:$AUTOCONF_DIR/spec.gmk.in"
16506 
16507   # The hotspot-spec.gmk file contains legacy variables for the hotspot make system.
16508   ac_config_files="$ac_config_files $OUTPUT_ROOT/hotspot-spec.gmk:$AUTOCONF_DIR/hotspot-spec.gmk.in"
16509 
16510   # The bootcycle-spec.gmk file contains support for boot cycle builds.
16511   ac_config_files="$ac_config_files $OUTPUT_ROOT/bootcycle-spec.gmk:$AUTOCONF_DIR/bootcycle-spec.gmk.in"
16512 
16513   # The compare.sh is used to compare the build output to other builds.
16514   ac_config_files="$ac_config_files $OUTPUT_ROOT/compare.sh:$AUTOCONF_DIR/compare.sh.in"
16515 
16516   # The generated Makefile knows where the spec.gmk is and where the source is.
16517   # You can run make from the OUTPUT_ROOT, or from the top-level Makefile
16518   # which will look for generated configurations
16519   ac_config_files="$ac_config_files $OUTPUT_ROOT/Makefile:$AUTOCONF_DIR/Makefile.in"
16520 
16521 
16522 
16523 # Must be done before we can call HELP_MSG_MISSING_DEPENDENCY.
16524 
16525   for ac_prog in apt-get yum port pkgutil pkgadd
16526 do
16527   # Extract the first word of "$ac_prog", so it can be a program name with args.
16528 set dummy $ac_prog; ac_word=$2
16529 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
16530 $as_echo_n "checking for $ac_word... " >&6; }
16531 if ${ac_cv_prog_PKGHANDLER+:} false; then :
16532   $as_echo_n "(cached) " >&6
16533 else
16534   if test -n "$PKGHANDLER"; then
16535   ac_cv_prog_PKGHANDLER="$PKGHANDLER" # Let the user override the test.
16536 else
16537 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
16538 for as_dir in $PATH
16539 do
16540   IFS=$as_save_IFS
16541   test -z "$as_dir" && as_dir=.
16542     for ac_exec_ext in '' $ac_executable_extensions; do
16543   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
16544     ac_cv_prog_PKGHANDLER="$ac_prog"
16545     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
16546     break 2
16547   fi
16548 done
16549   done
16550 IFS=$as_save_IFS
16551 
16552 fi
16553 fi
16554 PKGHANDLER=$ac_cv_prog_PKGHANDLER
16555 if test -n "$PKGHANDLER"; then
16556   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKGHANDLER" >&5
16557 $as_echo "$PKGHANDLER" >&6; }
16558 else
16559   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
16560 $as_echo "no" >&6; }
16561 fi
16562 
16563 
16564   test -n "$PKGHANDLER" && break
16565 done
16566 
16567 
16568 
16569 # Setup tools that requires more complex handling, or that is not needed by the configure script.
16570 
16571 
16572 
16573   # Publish this variable in the help.
16574 
16575 
16576   if [ -z "${MAKE+x}" ]; then
16577     # The variable is not set by user, try to locate tool using the code snippet
16578 
16579     # Try our hardest to locate a correct version of GNU make
16580     for ac_prog in gmake
16581 do
16582   # Extract the first word of "$ac_prog", so it can be a program name with args.
16583 set dummy $ac_prog; ac_word=$2
16584 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
16585 $as_echo_n "checking for $ac_word... " >&6; }
16586 if ${ac_cv_path_CHECK_GMAKE+:} false; then :
16587   $as_echo_n "(cached) " >&6
16588 else
16589   case $CHECK_GMAKE in
16590   [\\/]* | ?:[\\/]*)
16591   ac_cv_path_CHECK_GMAKE="$CHECK_GMAKE" # Let the user override the test with a path.
16592   ;;
16593   *)
16594   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
16595 for as_dir in $PATH
16596 do
16597   IFS=$as_save_IFS
16598   test -z "$as_dir" && as_dir=.
16599     for ac_exec_ext in '' $ac_executable_extensions; do
16600   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
16601     ac_cv_path_CHECK_GMAKE="$as_dir/$ac_word$ac_exec_ext"
16602     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
16603     break 2
16604   fi
16605 done
16606   done
16607 IFS=$as_save_IFS
16608 
16609   ;;
16610 esac
16611 fi
16612 CHECK_GMAKE=$ac_cv_path_CHECK_GMAKE
16613 if test -n "$CHECK_GMAKE"; then
16614   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_GMAKE" >&5
16615 $as_echo "$CHECK_GMAKE" >&6; }
16616 else
16617   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
16618 $as_echo "no" >&6; }
16619 fi
16620 
16621 
16622   test -n "$CHECK_GMAKE" && break
16623 done
16624 
16625 
16626   MAKE_CANDIDATE=""$CHECK_GMAKE""
16627   DESCRIPTION="gmake in PATH"
16628 
16629   # On Cygwin, we require a newer version of make than on other platforms
16630   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16631     MAKE_VERSION_EXPR="-e 4\."
16632     MAKE_REQUIRED_VERSION="4.0"
16633    else
16634     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
16635     MAKE_REQUIRED_VERSION="3.81"
16636   fi
16637 
16638   if test "x$MAKE_CANDIDATE" != x; then
16639     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
16640 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
16641     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
16642     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
16643     if test "x$IS_GNU_MAKE" = x; then
16644       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
16645 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
16646     else
16647       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
16648       if test "x$IS_MODERN_MAKE" = x; then
16649         { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version $MAKE_REQUIRED_VERSION or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
16650 $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version $MAKE_REQUIRED_VERSION or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
16651       else
16652         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
16653           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16654             MAKE_EXPECTED_ENV='cygwin'
16655           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16656             MAKE_EXPECTED_ENV='msys'
16657           else
16658             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
16659           fi
16660           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
16661           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
16662         else
16663           # Not relevant for non-Windows
16664           IS_MAKE_CORRECT_ENV=true
16665         fi
16666         if test "x$IS_MAKE_CORRECT_ENV" = x; then
16667           { $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
16668 $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;}
16669         else
16670           FOUND_MAKE=$MAKE_CANDIDATE
16671 
16672   # Only process if variable expands to non-empty
16673 
16674   if test "x$FOUND_MAKE" != x; then
16675     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16676 
16677   # First separate the path from the arguments. This will split at the first
16678   # space.
16679   complete="$FOUND_MAKE"
16680   path="${complete%% *}"
16681   tmp="$complete EOL"
16682   arguments="${tmp#* }"
16683 
16684   # Input might be given as Windows format, start by converting to
16685   # unix format.
16686   new_path=`$CYGPATH -u "$path"`
16687 
16688   # Now try to locate executable using which
16689   new_path=`$WHICH "$new_path" 2> /dev/null`
16690   # bat and cmd files are not always considered executable in cygwin causing which
16691   # to not find them
16692   if test "x$new_path" = x \
16693       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16694       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16695     new_path=`$CYGPATH -u "$path"`
16696   fi
16697   if test "x$new_path" = x; then
16698     # Oops. Which didn't find the executable.
16699     # The splitting of arguments from the executable at a space might have been incorrect,
16700     # since paths with space are more likely in Windows. Give it another try with the whole
16701     # argument.
16702     path="$complete"
16703     arguments="EOL"
16704     new_path=`$CYGPATH -u "$path"`
16705     new_path=`$WHICH "$new_path" 2> /dev/null`
16706     # bat and cmd files are not always considered executable in cygwin causing which
16707     # to not find them
16708     if test "x$new_path" = x \
16709         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16710         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16711       new_path=`$CYGPATH -u "$path"`
16712     fi
16713     if test "x$new_path" = x; then
16714       # It's still not found. Now this is an unrecoverable error.
16715       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16716 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16717       has_space=`$ECHO "$complete" | $GREP " "`
16718       if test "x$has_space" != x; then
16719         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16720 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16721       fi
16722       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16723     fi
16724   fi
16725 
16726   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
16727   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
16728   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
16729   # "foo.exe" is OK but "foo" is an error.
16730   #
16731   # This test is therefore slightly more accurate than "test -f" to check for file presence.
16732   # It is also a way to make sure we got the proper file name for the real test later on.
16733   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
16734   if test "x$test_shortpath" = x; then
16735     # Short path failed, file does not exist as specified.
16736     # Try adding .exe or .cmd
16737     if test -f "${new_path}.exe"; then
16738       input_to_shortpath="${new_path}.exe"
16739     elif test -f "${new_path}.cmd"; then
16740       input_to_shortpath="${new_path}.cmd"
16741     else
16742       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
16743 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
16744       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
16745 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
16746       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16747     fi
16748   else
16749     input_to_shortpath="$new_path"
16750   fi
16751 
16752   # Call helper function which possibly converts this using DOS-style short mode.
16753   # If so, the updated path is stored in $new_path.
16754   new_path="$input_to_shortpath"
16755 
16756   input_path="$input_to_shortpath"
16757   # Check if we need to convert this using DOS-style short mode. If the path
16758   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16759   # take no chances and rewrite it.
16760   # Note: m4 eats our [], so we need to use [ and ] instead.
16761   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
16762   if test "x$has_forbidden_chars" != x; then
16763     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16764     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
16765     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
16766     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
16767       # Going to short mode and back again did indeed matter. Since short mode is
16768       # case insensitive, let's make it lowercase to improve readability.
16769       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16770       # Now convert it back to Unix-style (cygpath)
16771       input_path=`$CYGPATH -u "$shortmode_path"`
16772       new_path="$input_path"
16773     fi
16774   fi
16775 
16776   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
16777   if test "x$test_cygdrive_prefix" = x; then
16778     # As a simple fix, exclude /usr/bin since it's not a real path.
16779     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
16780       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
16781       # a path prefixed by /cygdrive for fixpath to work.
16782       new_path="$CYGWIN_ROOT_PATH$input_path"
16783     fi
16784   fi
16785 
16786   # remove trailing .exe if any
16787   new_path="${new_path/%.exe/}"
16788 
16789     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16790 
16791   # First separate the path from the arguments. This will split at the first
16792   # space.
16793   complete="$FOUND_MAKE"
16794   path="${complete%% *}"
16795   tmp="$complete EOL"
16796   arguments="${tmp#* }"
16797 
16798   # Input might be given as Windows format, start by converting to
16799   # unix format.
16800   new_path="$path"
16801 
16802   windows_path="$new_path"
16803   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16804     unix_path=`$CYGPATH -u "$windows_path"`
16805     new_path="$unix_path"
16806   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16807     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16808     new_path="$unix_path"
16809   fi
16810 
16811 
16812   # Now try to locate executable using which
16813   new_path=`$WHICH "$new_path" 2> /dev/null`
16814 
16815   if test "x$new_path" = x; then
16816     # Oops. Which didn't find the executable.
16817     # The splitting of arguments from the executable at a space might have been incorrect,
16818     # since paths with space are more likely in Windows. Give it another try with the whole
16819     # argument.
16820     path="$complete"
16821     arguments="EOL"
16822     new_path="$path"
16823 
16824   windows_path="$new_path"
16825   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16826     unix_path=`$CYGPATH -u "$windows_path"`
16827     new_path="$unix_path"
16828   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16829     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16830     new_path="$unix_path"
16831   fi
16832 
16833 
16834     new_path=`$WHICH "$new_path" 2> /dev/null`
16835     # bat and cmd files are not always considered executable in MSYS causing which
16836     # to not find them
16837     if test "x$new_path" = x \
16838         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16839         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16840       new_path="$path"
16841 
16842   windows_path="$new_path"
16843   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16844     unix_path=`$CYGPATH -u "$windows_path"`
16845     new_path="$unix_path"
16846   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16847     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16848     new_path="$unix_path"
16849   fi
16850 
16851     fi
16852 
16853     if test "x$new_path" = x; then
16854       # It's still not found. Now this is an unrecoverable error.
16855       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16856 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16857       has_space=`$ECHO "$complete" | $GREP " "`
16858       if test "x$has_space" != x; then
16859         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16860 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16861       fi
16862       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16863     fi
16864   fi
16865 
16866   # Now new_path has a complete unix path to the binary
16867   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
16868     # Keep paths in /bin as-is, but remove trailing .exe if any
16869     new_path="${new_path/%.exe/}"
16870     # Do not save /bin paths to all_fixpath_prefixes!
16871   else
16872     # Not in mixed or Windows style, start by that.
16873     new_path=`cmd //c echo $new_path`
16874 
16875   input_path="$new_path"
16876   # Check if we need to convert this using DOS-style short mode. If the path
16877   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16878   # take no chances and rewrite it.
16879   # Note: m4 eats our [], so we need to use [ and ] instead.
16880   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
16881   if test "x$has_forbidden_chars" != x; then
16882     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16883     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16884   fi
16885 
16886     # Output is in $new_path
16887 
16888   windows_path="$new_path"
16889   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16890     unix_path=`$CYGPATH -u "$windows_path"`
16891     new_path="$unix_path"
16892   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16893     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16894     new_path="$unix_path"
16895   fi
16896 
16897     # remove trailing .exe if any
16898     new_path="${new_path/%.exe/}"
16899 
16900     # Save the first 10 bytes of this path to the storage, so fixpath can work.
16901     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
16902   fi
16903 
16904     else
16905       # We're on a unix platform. Hooray! :)
16906       # First separate the path from the arguments. This will split at the first
16907       # space.
16908       complete="$FOUND_MAKE"
16909       path="${complete%% *}"
16910       tmp="$complete EOL"
16911       arguments="${tmp#* }"
16912 
16913       # Cannot rely on the command "which" here since it doesn't always work.
16914       is_absolute_path=`$ECHO "$path" | $GREP ^/`
16915       if test -z "$is_absolute_path"; then
16916         # Path to executable is not absolute. Find it.
16917         IFS_save="$IFS"
16918         IFS=:
16919         for p in $PATH; do
16920           if test -f "$p/$path" && test -x "$p/$path"; then
16921             new_path="$p/$path"
16922             break
16923           fi
16924         done
16925         IFS="$IFS_save"
16926       else
16927         # This is an absolute path, we can use it without further modifications.
16928         new_path="$path"
16929       fi
16930 
16931       if test "x$new_path" = x; then
16932         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16933 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16934         has_space=`$ECHO "$complete" | $GREP " "`
16935         if test "x$has_space" != x; then
16936           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
16937 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
16938         fi
16939         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16940       fi
16941     fi
16942 
16943     # Now join together the path and the arguments once again
16944     if test "x$arguments" != xEOL; then
16945       new_complete="$new_path ${arguments% *}"
16946     else
16947       new_complete="$new_path"
16948     fi
16949 
16950     if test "x$complete" != "x$new_complete"; then
16951       FOUND_MAKE="$new_complete"
16952       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
16953 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
16954     fi
16955   fi
16956 
16957         fi
16958       fi
16959     fi
16960   fi
16961 
16962 
16963     if test "x$FOUND_MAKE" = x; then
16964       for ac_prog in make
16965 do
16966   # Extract the first word of "$ac_prog", so it can be a program name with args.
16967 set dummy $ac_prog; ac_word=$2
16968 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
16969 $as_echo_n "checking for $ac_word... " >&6; }
16970 if ${ac_cv_path_CHECK_MAKE+:} false; then :
16971   $as_echo_n "(cached) " >&6
16972 else
16973   case $CHECK_MAKE in
16974   [\\/]* | ?:[\\/]*)
16975   ac_cv_path_CHECK_MAKE="$CHECK_MAKE" # Let the user override the test with a path.
16976   ;;
16977   *)
16978   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
16979 for as_dir in $PATH
16980 do
16981   IFS=$as_save_IFS
16982   test -z "$as_dir" && as_dir=.
16983     for ac_exec_ext in '' $ac_executable_extensions; do
16984   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
16985     ac_cv_path_CHECK_MAKE="$as_dir/$ac_word$ac_exec_ext"
16986     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
16987     break 2
16988   fi
16989 done
16990   done
16991 IFS=$as_save_IFS
16992 
16993   ;;
16994 esac
16995 fi
16996 CHECK_MAKE=$ac_cv_path_CHECK_MAKE
16997 if test -n "$CHECK_MAKE"; then
16998   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_MAKE" >&5
16999 $as_echo "$CHECK_MAKE" >&6; }
17000 else
17001   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17002 $as_echo "no" >&6; }
17003 fi
17004 
17005 
17006   test -n "$CHECK_MAKE" && break
17007 done
17008 
17009 
17010   MAKE_CANDIDATE=""$CHECK_MAKE""
17011   DESCRIPTION="make in PATH"
17012 
17013   # On Cygwin, we require a newer version of make than on other platforms
17014   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17015     MAKE_VERSION_EXPR="-e 4\."
17016     MAKE_REQUIRED_VERSION="4.0"
17017    else
17018     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
17019     MAKE_REQUIRED_VERSION="3.81"
17020   fi
17021 
17022   if test "x$MAKE_CANDIDATE" != x; then
17023     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
17024 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
17025     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
17026     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
17027     if test "x$IS_GNU_MAKE" = x; then
17028       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
17029 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
17030     else
17031       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
17032       if test "x$IS_MODERN_MAKE" = x; then
17033         { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version $MAKE_REQUIRED_VERSION or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
17034 $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version $MAKE_REQUIRED_VERSION or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
17035       else
17036         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
17037           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17038             MAKE_EXPECTED_ENV='cygwin'
17039           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17040             MAKE_EXPECTED_ENV='msys'
17041           else
17042             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
17043           fi
17044           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
17045           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
17046         else
17047           # Not relevant for non-Windows
17048           IS_MAKE_CORRECT_ENV=true
17049         fi
17050         if test "x$IS_MAKE_CORRECT_ENV" = x; then
17051           { $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
17052 $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;}
17053         else
17054           FOUND_MAKE=$MAKE_CANDIDATE
17055 
17056   # Only process if variable expands to non-empty
17057 
17058   if test "x$FOUND_MAKE" != x; then
17059     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17060 
17061   # First separate the path from the arguments. This will split at the first
17062   # space.
17063   complete="$FOUND_MAKE"
17064   path="${complete%% *}"
17065   tmp="$complete EOL"
17066   arguments="${tmp#* }"
17067 
17068   # Input might be given as Windows format, start by converting to
17069   # unix format.
17070   new_path=`$CYGPATH -u "$path"`
17071 
17072   # Now try to locate executable using which
17073   new_path=`$WHICH "$new_path" 2> /dev/null`
17074   # bat and cmd files are not always considered executable in cygwin causing which
17075   # to not find them
17076   if test "x$new_path" = x \
17077       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17078       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17079     new_path=`$CYGPATH -u "$path"`
17080   fi
17081   if test "x$new_path" = x; then
17082     # Oops. Which didn't find the executable.
17083     # The splitting of arguments from the executable at a space might have been incorrect,
17084     # since paths with space are more likely in Windows. Give it another try with the whole
17085     # argument.
17086     path="$complete"
17087     arguments="EOL"
17088     new_path=`$CYGPATH -u "$path"`
17089     new_path=`$WHICH "$new_path" 2> /dev/null`
17090     # bat and cmd files are not always considered executable in cygwin causing which
17091     # to not find them
17092     if test "x$new_path" = x \
17093         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17094         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17095       new_path=`$CYGPATH -u "$path"`
17096     fi
17097     if test "x$new_path" = x; then
17098       # It's still not found. Now this is an unrecoverable error.
17099       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17100 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17101       has_space=`$ECHO "$complete" | $GREP " "`
17102       if test "x$has_space" != x; then
17103         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
17104 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
17105       fi
17106       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17107     fi
17108   fi
17109 
17110   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
17111   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
17112   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
17113   # "foo.exe" is OK but "foo" is an error.
17114   #
17115   # This test is therefore slightly more accurate than "test -f" to check for file presence.
17116   # It is also a way to make sure we got the proper file name for the real test later on.
17117   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
17118   if test "x$test_shortpath" = x; then
17119     # Short path failed, file does not exist as specified.
17120     # Try adding .exe or .cmd
17121     if test -f "${new_path}.exe"; then
17122       input_to_shortpath="${new_path}.exe"
17123     elif test -f "${new_path}.cmd"; then
17124       input_to_shortpath="${new_path}.cmd"
17125     else
17126       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
17127 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
17128       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
17129 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
17130       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17131     fi
17132   else
17133     input_to_shortpath="$new_path"
17134   fi
17135 
17136   # Call helper function which possibly converts this using DOS-style short mode.
17137   # If so, the updated path is stored in $new_path.
17138   new_path="$input_to_shortpath"
17139 
17140   input_path="$input_to_shortpath"
17141   # Check if we need to convert this using DOS-style short mode. If the path
17142   # contains just simple characters, use it. Otherwise (spaces, weird characters),
17143   # take no chances and rewrite it.
17144   # Note: m4 eats our [], so we need to use [ and ] instead.
17145   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
17146   if test "x$has_forbidden_chars" != x; then
17147     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
17148     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
17149     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
17150     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
17151       # Going to short mode and back again did indeed matter. Since short mode is
17152       # case insensitive, let's make it lowercase to improve readability.
17153       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
17154       # Now convert it back to Unix-style (cygpath)
17155       input_path=`$CYGPATH -u "$shortmode_path"`
17156       new_path="$input_path"
17157     fi
17158   fi
17159 
17160   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
17161   if test "x$test_cygdrive_prefix" = x; then
17162     # As a simple fix, exclude /usr/bin since it's not a real path.
17163     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
17164       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
17165       # a path prefixed by /cygdrive for fixpath to work.
17166       new_path="$CYGWIN_ROOT_PATH$input_path"
17167     fi
17168   fi
17169 
17170   # remove trailing .exe if any
17171   new_path="${new_path/%.exe/}"
17172 
17173     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17174 
17175   # First separate the path from the arguments. This will split at the first
17176   # space.
17177   complete="$FOUND_MAKE"
17178   path="${complete%% *}"
17179   tmp="$complete EOL"
17180   arguments="${tmp#* }"
17181 
17182   # Input might be given as Windows format, start by converting to
17183   # unix format.
17184   new_path="$path"
17185 
17186   windows_path="$new_path"
17187   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17188     unix_path=`$CYGPATH -u "$windows_path"`
17189     new_path="$unix_path"
17190   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17191     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17192     new_path="$unix_path"
17193   fi
17194 
17195 
17196   # Now try to locate executable using which
17197   new_path=`$WHICH "$new_path" 2> /dev/null`
17198 
17199   if test "x$new_path" = x; then
17200     # Oops. Which didn't find the executable.
17201     # The splitting of arguments from the executable at a space might have been incorrect,
17202     # since paths with space are more likely in Windows. Give it another try with the whole
17203     # argument.
17204     path="$complete"
17205     arguments="EOL"
17206     new_path="$path"
17207 
17208   windows_path="$new_path"
17209   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17210     unix_path=`$CYGPATH -u "$windows_path"`
17211     new_path="$unix_path"
17212   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17213     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17214     new_path="$unix_path"
17215   fi
17216 
17217 
17218     new_path=`$WHICH "$new_path" 2> /dev/null`
17219     # bat and cmd files are not always considered executable in MSYS causing which
17220     # to not find them
17221     if test "x$new_path" = x \
17222         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17223         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17224       new_path="$path"
17225 
17226   windows_path="$new_path"
17227   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17228     unix_path=`$CYGPATH -u "$windows_path"`
17229     new_path="$unix_path"
17230   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17231     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17232     new_path="$unix_path"
17233   fi
17234 
17235     fi
17236 
17237     if test "x$new_path" = x; then
17238       # It's still not found. Now this is an unrecoverable error.
17239       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17240 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17241       has_space=`$ECHO "$complete" | $GREP " "`
17242       if test "x$has_space" != x; then
17243         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
17244 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
17245       fi
17246       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17247     fi
17248   fi
17249 
17250   # Now new_path has a complete unix path to the binary
17251   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
17252     # Keep paths in /bin as-is, but remove trailing .exe if any
17253     new_path="${new_path/%.exe/}"
17254     # Do not save /bin paths to all_fixpath_prefixes!
17255   else
17256     # Not in mixed or Windows style, start by that.
17257     new_path=`cmd //c echo $new_path`
17258 
17259   input_path="$new_path"
17260   # Check if we need to convert this using DOS-style short mode. If the path
17261   # contains just simple characters, use it. Otherwise (spaces, weird characters),
17262   # take no chances and rewrite it.
17263   # Note: m4 eats our [], so we need to use [ and ] instead.
17264   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
17265   if test "x$has_forbidden_chars" != x; then
17266     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
17267     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
17268   fi
17269 
17270     # Output is in $new_path
17271 
17272   windows_path="$new_path"
17273   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17274     unix_path=`$CYGPATH -u "$windows_path"`
17275     new_path="$unix_path"
17276   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17277     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17278     new_path="$unix_path"
17279   fi
17280 
17281     # remove trailing .exe if any
17282     new_path="${new_path/%.exe/}"
17283 
17284     # Save the first 10 bytes of this path to the storage, so fixpath can work.
17285     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
17286   fi
17287 
17288     else
17289       # We're on a unix platform. Hooray! :)
17290       # First separate the path from the arguments. This will split at the first
17291       # space.
17292       complete="$FOUND_MAKE"
17293       path="${complete%% *}"
17294       tmp="$complete EOL"
17295       arguments="${tmp#* }"
17296 
17297       # Cannot rely on the command "which" here since it doesn't always work.
17298       is_absolute_path=`$ECHO "$path" | $GREP ^/`
17299       if test -z "$is_absolute_path"; then
17300         # Path to executable is not absolute. Find it.
17301         IFS_save="$IFS"
17302         IFS=:
17303         for p in $PATH; do
17304           if test -f "$p/$path" && test -x "$p/$path"; then
17305             new_path="$p/$path"
17306             break
17307           fi
17308         done
17309         IFS="$IFS_save"
17310       else
17311         # This is an absolute path, we can use it without further modifications.
17312         new_path="$path"
17313       fi
17314 
17315       if test "x$new_path" = x; then
17316         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17317 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17318         has_space=`$ECHO "$complete" | $GREP " "`
17319         if test "x$has_space" != x; then
17320           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
17321 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
17322         fi
17323         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17324       fi
17325     fi
17326 
17327     # Now join together the path and the arguments once again
17328     if test "x$arguments" != xEOL; then
17329       new_complete="$new_path ${arguments% *}"
17330     else
17331       new_complete="$new_path"
17332     fi
17333 
17334     if test "x$complete" != "x$new_complete"; then
17335       FOUND_MAKE="$new_complete"
17336       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
17337 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
17338     fi
17339   fi
17340 
17341         fi
17342       fi
17343     fi
17344   fi
17345 
17346     fi
17347 
17348     if test "x$FOUND_MAKE" = x; then
17349       if test "x$TOOLCHAIN_PATH" != x; then
17350         # We have a toolchain path, check that as well before giving up.
17351         OLD_PATH=$PATH
17352         PATH=$TOOLCHAIN_PATH:$PATH
17353         for ac_prog in gmake
17354 do
17355   # Extract the first word of "$ac_prog", so it can be a program name with args.
17356 set dummy $ac_prog; ac_word=$2
17357 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17358 $as_echo_n "checking for $ac_word... " >&6; }
17359 if ${ac_cv_path_CHECK_TOOLSDIR_GMAKE+:} false; then :
17360   $as_echo_n "(cached) " >&6
17361 else
17362   case $CHECK_TOOLSDIR_GMAKE in
17363   [\\/]* | ?:[\\/]*)
17364   ac_cv_path_CHECK_TOOLSDIR_GMAKE="$CHECK_TOOLSDIR_GMAKE" # Let the user override the test with a path.
17365   ;;
17366   *)
17367   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17368 for as_dir in $PATH
17369 do
17370   IFS=$as_save_IFS
17371   test -z "$as_dir" && as_dir=.
17372     for ac_exec_ext in '' $ac_executable_extensions; do
17373   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17374     ac_cv_path_CHECK_TOOLSDIR_GMAKE="$as_dir/$ac_word$ac_exec_ext"
17375     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17376     break 2
17377   fi
17378 done
17379   done
17380 IFS=$as_save_IFS
17381 
17382   ;;
17383 esac
17384 fi
17385 CHECK_TOOLSDIR_GMAKE=$ac_cv_path_CHECK_TOOLSDIR_GMAKE
17386 if test -n "$CHECK_TOOLSDIR_GMAKE"; then
17387   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_GMAKE" >&5
17388 $as_echo "$CHECK_TOOLSDIR_GMAKE" >&6; }
17389 else
17390   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17391 $as_echo "no" >&6; }
17392 fi
17393 
17394 
17395   test -n "$CHECK_TOOLSDIR_GMAKE" && break
17396 done
17397 
17398 
17399   MAKE_CANDIDATE=""$CHECK_TOOLSDIR_GMAKE""
17400   DESCRIPTION="gmake in tools-dir"
17401 
17402   # On Cygwin, we require a newer version of make than on other platforms
17403   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17404     MAKE_VERSION_EXPR="-e 4\."
17405     MAKE_REQUIRED_VERSION="4.0"
17406    else
17407     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
17408     MAKE_REQUIRED_VERSION="3.81"
17409   fi
17410 
17411   if test "x$MAKE_CANDIDATE" != x; then
17412     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
17413 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
17414     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
17415     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
17416     if test "x$IS_GNU_MAKE" = x; then
17417       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
17418 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
17419     else
17420       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
17421       if test "x$IS_MODERN_MAKE" = x; then
17422         { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version $MAKE_REQUIRED_VERSION or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
17423 $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version $MAKE_REQUIRED_VERSION or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
17424       else
17425         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
17426           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17427             MAKE_EXPECTED_ENV='cygwin'
17428           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17429             MAKE_EXPECTED_ENV='msys'
17430           else
17431             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
17432           fi
17433           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
17434           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
17435         else
17436           # Not relevant for non-Windows
17437           IS_MAKE_CORRECT_ENV=true
17438         fi
17439         if test "x$IS_MAKE_CORRECT_ENV" = x; then
17440           { $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
17441 $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;}
17442         else
17443           FOUND_MAKE=$MAKE_CANDIDATE
17444 
17445   # Only process if variable expands to non-empty
17446 
17447   if test "x$FOUND_MAKE" != x; then
17448     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17449 
17450   # First separate the path from the arguments. This will split at the first
17451   # space.
17452   complete="$FOUND_MAKE"
17453   path="${complete%% *}"
17454   tmp="$complete EOL"
17455   arguments="${tmp#* }"
17456 
17457   # Input might be given as Windows format, start by converting to
17458   # unix format.
17459   new_path=`$CYGPATH -u "$path"`
17460 
17461   # Now try to locate executable using which
17462   new_path=`$WHICH "$new_path" 2> /dev/null`
17463   # bat and cmd files are not always considered executable in cygwin causing which
17464   # to not find them
17465   if test "x$new_path" = x \
17466       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17467       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17468     new_path=`$CYGPATH -u "$path"`
17469   fi
17470   if test "x$new_path" = x; then
17471     # Oops. Which didn't find the executable.
17472     # The splitting of arguments from the executable at a space might have been incorrect,
17473     # since paths with space are more likely in Windows. Give it another try with the whole
17474     # argument.
17475     path="$complete"
17476     arguments="EOL"
17477     new_path=`$CYGPATH -u "$path"`
17478     new_path=`$WHICH "$new_path" 2> /dev/null`
17479     # bat and cmd files are not always considered executable in cygwin causing which
17480     # to not find them
17481     if test "x$new_path" = x \
17482         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17483         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17484       new_path=`$CYGPATH -u "$path"`
17485     fi
17486     if test "x$new_path" = x; then
17487       # It's still not found. Now this is an unrecoverable error.
17488       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17489 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17490       has_space=`$ECHO "$complete" | $GREP " "`
17491       if test "x$has_space" != x; then
17492         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
17493 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
17494       fi
17495       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17496     fi
17497   fi
17498 
17499   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
17500   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
17501   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
17502   # "foo.exe" is OK but "foo" is an error.
17503   #
17504   # This test is therefore slightly more accurate than "test -f" to check for file presence.
17505   # It is also a way to make sure we got the proper file name for the real test later on.
17506   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
17507   if test "x$test_shortpath" = x; then
17508     # Short path failed, file does not exist as specified.
17509     # Try adding .exe or .cmd
17510     if test -f "${new_path}.exe"; then
17511       input_to_shortpath="${new_path}.exe"
17512     elif test -f "${new_path}.cmd"; then
17513       input_to_shortpath="${new_path}.cmd"
17514     else
17515       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
17516 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
17517       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
17518 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
17519       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17520     fi
17521   else
17522     input_to_shortpath="$new_path"
17523   fi
17524 
17525   # Call helper function which possibly converts this using DOS-style short mode.
17526   # If so, the updated path is stored in $new_path.
17527   new_path="$input_to_shortpath"
17528 
17529   input_path="$input_to_shortpath"
17530   # Check if we need to convert this using DOS-style short mode. If the path
17531   # contains just simple characters, use it. Otherwise (spaces, weird characters),
17532   # take no chances and rewrite it.
17533   # Note: m4 eats our [], so we need to use [ and ] instead.
17534   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
17535   if test "x$has_forbidden_chars" != x; then
17536     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
17537     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
17538     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
17539     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
17540       # Going to short mode and back again did indeed matter. Since short mode is
17541       # case insensitive, let's make it lowercase to improve readability.
17542       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
17543       # Now convert it back to Unix-style (cygpath)
17544       input_path=`$CYGPATH -u "$shortmode_path"`
17545       new_path="$input_path"
17546     fi
17547   fi
17548 
17549   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
17550   if test "x$test_cygdrive_prefix" = x; then
17551     # As a simple fix, exclude /usr/bin since it's not a real path.
17552     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
17553       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
17554       # a path prefixed by /cygdrive for fixpath to work.
17555       new_path="$CYGWIN_ROOT_PATH$input_path"
17556     fi
17557   fi
17558 
17559   # remove trailing .exe if any
17560   new_path="${new_path/%.exe/}"
17561 
17562     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17563 
17564   # First separate the path from the arguments. This will split at the first
17565   # space.
17566   complete="$FOUND_MAKE"
17567   path="${complete%% *}"
17568   tmp="$complete EOL"
17569   arguments="${tmp#* }"
17570 
17571   # Input might be given as Windows format, start by converting to
17572   # unix format.
17573   new_path="$path"
17574 
17575   windows_path="$new_path"
17576   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17577     unix_path=`$CYGPATH -u "$windows_path"`
17578     new_path="$unix_path"
17579   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17580     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17581     new_path="$unix_path"
17582   fi
17583 
17584 
17585   # Now try to locate executable using which
17586   new_path=`$WHICH "$new_path" 2> /dev/null`
17587 
17588   if test "x$new_path" = x; then
17589     # Oops. Which didn't find the executable.
17590     # The splitting of arguments from the executable at a space might have been incorrect,
17591     # since paths with space are more likely in Windows. Give it another try with the whole
17592     # argument.
17593     path="$complete"
17594     arguments="EOL"
17595     new_path="$path"
17596 
17597   windows_path="$new_path"
17598   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17599     unix_path=`$CYGPATH -u "$windows_path"`
17600     new_path="$unix_path"
17601   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17602     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17603     new_path="$unix_path"
17604   fi
17605 
17606 
17607     new_path=`$WHICH "$new_path" 2> /dev/null`
17608     # bat and cmd files are not always considered executable in MSYS causing which
17609     # to not find them
17610     if test "x$new_path" = x \
17611         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17612         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17613       new_path="$path"
17614 
17615   windows_path="$new_path"
17616   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17617     unix_path=`$CYGPATH -u "$windows_path"`
17618     new_path="$unix_path"
17619   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17620     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17621     new_path="$unix_path"
17622   fi
17623 
17624     fi
17625 
17626     if test "x$new_path" = x; then
17627       # It's still not found. Now this is an unrecoverable error.
17628       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17629 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17630       has_space=`$ECHO "$complete" | $GREP " "`
17631       if test "x$has_space" != x; then
17632         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
17633 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
17634       fi
17635       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17636     fi
17637   fi
17638 
17639   # Now new_path has a complete unix path to the binary
17640   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
17641     # Keep paths in /bin as-is, but remove trailing .exe if any
17642     new_path="${new_path/%.exe/}"
17643     # Do not save /bin paths to all_fixpath_prefixes!
17644   else
17645     # Not in mixed or Windows style, start by that.
17646     new_path=`cmd //c echo $new_path`
17647 
17648   input_path="$new_path"
17649   # Check if we need to convert this using DOS-style short mode. If the path
17650   # contains just simple characters, use it. Otherwise (spaces, weird characters),
17651   # take no chances and rewrite it.
17652   # Note: m4 eats our [], so we need to use [ and ] instead.
17653   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
17654   if test "x$has_forbidden_chars" != x; then
17655     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
17656     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
17657   fi
17658 
17659     # Output is in $new_path
17660 
17661   windows_path="$new_path"
17662   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17663     unix_path=`$CYGPATH -u "$windows_path"`
17664     new_path="$unix_path"
17665   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17666     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17667     new_path="$unix_path"
17668   fi
17669 
17670     # remove trailing .exe if any
17671     new_path="${new_path/%.exe/}"
17672 
17673     # Save the first 10 bytes of this path to the storage, so fixpath can work.
17674     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
17675   fi
17676 
17677     else
17678       # We're on a unix platform. Hooray! :)
17679       # First separate the path from the arguments. This will split at the first
17680       # space.
17681       complete="$FOUND_MAKE"
17682       path="${complete%% *}"
17683       tmp="$complete EOL"
17684       arguments="${tmp#* }"
17685 
17686       # Cannot rely on the command "which" here since it doesn't always work.
17687       is_absolute_path=`$ECHO "$path" | $GREP ^/`
17688       if test -z "$is_absolute_path"; then
17689         # Path to executable is not absolute. Find it.
17690         IFS_save="$IFS"
17691         IFS=:
17692         for p in $PATH; do
17693           if test -f "$p/$path" && test -x "$p/$path"; then
17694             new_path="$p/$path"
17695             break
17696           fi
17697         done
17698         IFS="$IFS_save"
17699       else
17700         # This is an absolute path, we can use it without further modifications.
17701         new_path="$path"
17702       fi
17703 
17704       if test "x$new_path" = x; then
17705         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17706 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17707         has_space=`$ECHO "$complete" | $GREP " "`
17708         if test "x$has_space" != x; then
17709           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
17710 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
17711         fi
17712         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17713       fi
17714     fi
17715 
17716     # Now join together the path and the arguments once again
17717     if test "x$arguments" != xEOL; then
17718       new_complete="$new_path ${arguments% *}"
17719     else
17720       new_complete="$new_path"
17721     fi
17722 
17723     if test "x$complete" != "x$new_complete"; then
17724       FOUND_MAKE="$new_complete"
17725       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
17726 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
17727     fi
17728   fi
17729 
17730         fi
17731       fi
17732     fi
17733   fi
17734 
17735         if test "x$FOUND_MAKE" = x; then
17736           for ac_prog in make
17737 do
17738   # Extract the first word of "$ac_prog", so it can be a program name with args.
17739 set dummy $ac_prog; ac_word=$2
17740 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17741 $as_echo_n "checking for $ac_word... " >&6; }
17742 if ${ac_cv_path_CHECK_TOOLSDIR_MAKE+:} false; then :
17743   $as_echo_n "(cached) " >&6
17744 else
17745   case $CHECK_TOOLSDIR_MAKE in
17746   [\\/]* | ?:[\\/]*)
17747   ac_cv_path_CHECK_TOOLSDIR_MAKE="$CHECK_TOOLSDIR_MAKE" # Let the user override the test with a path.
17748   ;;
17749   *)
17750   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17751 for as_dir in $PATH
17752 do
17753   IFS=$as_save_IFS
17754   test -z "$as_dir" && as_dir=.
17755     for ac_exec_ext in '' $ac_executable_extensions; do
17756   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17757     ac_cv_path_CHECK_TOOLSDIR_MAKE="$as_dir/$ac_word$ac_exec_ext"
17758     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17759     break 2
17760   fi
17761 done
17762   done
17763 IFS=$as_save_IFS
17764 
17765   ;;
17766 esac
17767 fi
17768 CHECK_TOOLSDIR_MAKE=$ac_cv_path_CHECK_TOOLSDIR_MAKE
17769 if test -n "$CHECK_TOOLSDIR_MAKE"; then
17770   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_MAKE" >&5
17771 $as_echo "$CHECK_TOOLSDIR_MAKE" >&6; }
17772 else
17773   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17774 $as_echo "no" >&6; }
17775 fi
17776 
17777 
17778   test -n "$CHECK_TOOLSDIR_MAKE" && break
17779 done
17780 
17781 
17782   MAKE_CANDIDATE=""$CHECK_TOOLSDIR_MAKE""
17783   DESCRIPTION="make in tools-dir"
17784 
17785   # On Cygwin, we require a newer version of make than on other platforms
17786   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17787     MAKE_VERSION_EXPR="-e 4\."
17788     MAKE_REQUIRED_VERSION="4.0"
17789    else
17790     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
17791     MAKE_REQUIRED_VERSION="3.81"
17792   fi
17793 
17794   if test "x$MAKE_CANDIDATE" != x; then
17795     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
17796 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
17797     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
17798     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
17799     if test "x$IS_GNU_MAKE" = x; then
17800       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
17801 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
17802     else
17803       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
17804       if test "x$IS_MODERN_MAKE" = x; then
17805         { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version $MAKE_REQUIRED_VERSION or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
17806 $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version $MAKE_REQUIRED_VERSION or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
17807       else
17808         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
17809           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17810             MAKE_EXPECTED_ENV='cygwin'
17811           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17812             MAKE_EXPECTED_ENV='msys'
17813           else
17814             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
17815           fi
17816           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
17817           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
17818         else
17819           # Not relevant for non-Windows
17820           IS_MAKE_CORRECT_ENV=true
17821         fi
17822         if test "x$IS_MAKE_CORRECT_ENV" = x; then
17823           { $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
17824 $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;}
17825         else
17826           FOUND_MAKE=$MAKE_CANDIDATE
17827 
17828   # Only process if variable expands to non-empty
17829 
17830   if test "x$FOUND_MAKE" != x; then
17831     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17832 
17833   # First separate the path from the arguments. This will split at the first
17834   # space.
17835   complete="$FOUND_MAKE"
17836   path="${complete%% *}"
17837   tmp="$complete EOL"
17838   arguments="${tmp#* }"
17839 
17840   # Input might be given as Windows format, start by converting to
17841   # unix format.
17842   new_path=`$CYGPATH -u "$path"`
17843 
17844   # Now try to locate executable using which
17845   new_path=`$WHICH "$new_path" 2> /dev/null`
17846   # bat and cmd files are not always considered executable in cygwin causing which
17847   # to not find them
17848   if test "x$new_path" = x \
17849       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17850       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17851     new_path=`$CYGPATH -u "$path"`
17852   fi
17853   if test "x$new_path" = x; then
17854     # Oops. Which didn't find the executable.
17855     # The splitting of arguments from the executable at a space might have been incorrect,
17856     # since paths with space are more likely in Windows. Give it another try with the whole
17857     # argument.
17858     path="$complete"
17859     arguments="EOL"
17860     new_path=`$CYGPATH -u "$path"`
17861     new_path=`$WHICH "$new_path" 2> /dev/null`
17862     # bat and cmd files are not always considered executable in cygwin causing which
17863     # to not find them
17864     if test "x$new_path" = x \
17865         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17866         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17867       new_path=`$CYGPATH -u "$path"`
17868     fi
17869     if test "x$new_path" = x; then
17870       # It's still not found. Now this is an unrecoverable error.
17871       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17872 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17873       has_space=`$ECHO "$complete" | $GREP " "`
17874       if test "x$has_space" != x; then
17875         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
17876 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
17877       fi
17878       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17879     fi
17880   fi
17881 
17882   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
17883   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
17884   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
17885   # "foo.exe" is OK but "foo" is an error.
17886   #
17887   # This test is therefore slightly more accurate than "test -f" to check for file presence.
17888   # It is also a way to make sure we got the proper file name for the real test later on.
17889   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
17890   if test "x$test_shortpath" = x; then
17891     # Short path failed, file does not exist as specified.
17892     # Try adding .exe or .cmd
17893     if test -f "${new_path}.exe"; then
17894       input_to_shortpath="${new_path}.exe"
17895     elif test -f "${new_path}.cmd"; then
17896       input_to_shortpath="${new_path}.cmd"
17897     else
17898       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
17899 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
17900       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
17901 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
17902       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17903     fi
17904   else
17905     input_to_shortpath="$new_path"
17906   fi
17907 
17908   # Call helper function which possibly converts this using DOS-style short mode.
17909   # If so, the updated path is stored in $new_path.
17910   new_path="$input_to_shortpath"
17911 
17912   input_path="$input_to_shortpath"
17913   # Check if we need to convert this using DOS-style short mode. If the path
17914   # contains just simple characters, use it. Otherwise (spaces, weird characters),
17915   # take no chances and rewrite it.
17916   # Note: m4 eats our [], so we need to use [ and ] instead.
17917   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
17918   if test "x$has_forbidden_chars" != x; then
17919     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
17920     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
17921     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
17922     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
17923       # Going to short mode and back again did indeed matter. Since short mode is
17924       # case insensitive, let's make it lowercase to improve readability.
17925       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
17926       # Now convert it back to Unix-style (cygpath)
17927       input_path=`$CYGPATH -u "$shortmode_path"`
17928       new_path="$input_path"
17929     fi
17930   fi
17931 
17932   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
17933   if test "x$test_cygdrive_prefix" = x; then
17934     # As a simple fix, exclude /usr/bin since it's not a real path.
17935     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
17936       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
17937       # a path prefixed by /cygdrive for fixpath to work.
17938       new_path="$CYGWIN_ROOT_PATH$input_path"
17939     fi
17940   fi
17941 
17942   # remove trailing .exe if any
17943   new_path="${new_path/%.exe/}"
17944 
17945     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17946 
17947   # First separate the path from the arguments. This will split at the first
17948   # space.
17949   complete="$FOUND_MAKE"
17950   path="${complete%% *}"
17951   tmp="$complete EOL"
17952   arguments="${tmp#* }"
17953 
17954   # Input might be given as Windows format, start by converting to
17955   # unix format.
17956   new_path="$path"
17957 
17958   windows_path="$new_path"
17959   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17960     unix_path=`$CYGPATH -u "$windows_path"`
17961     new_path="$unix_path"
17962   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17963     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17964     new_path="$unix_path"
17965   fi
17966 
17967 
17968   # Now try to locate executable using which
17969   new_path=`$WHICH "$new_path" 2> /dev/null`
17970 
17971   if test "x$new_path" = x; then
17972     # Oops. Which didn't find the executable.
17973     # The splitting of arguments from the executable at a space might have been incorrect,
17974     # since paths with space are more likely in Windows. Give it another try with the whole
17975     # argument.
17976     path="$complete"
17977     arguments="EOL"
17978     new_path="$path"
17979 
17980   windows_path="$new_path"
17981   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17982     unix_path=`$CYGPATH -u "$windows_path"`
17983     new_path="$unix_path"
17984   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17985     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17986     new_path="$unix_path"
17987   fi
17988 
17989 
17990     new_path=`$WHICH "$new_path" 2> /dev/null`
17991     # bat and cmd files are not always considered executable in MSYS causing which
17992     # to not find them
17993     if test "x$new_path" = x \
17994         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17995         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17996       new_path="$path"
17997 
17998   windows_path="$new_path"
17999   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18000     unix_path=`$CYGPATH -u "$windows_path"`
18001     new_path="$unix_path"
18002   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18003     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18004     new_path="$unix_path"
18005   fi
18006 
18007     fi
18008 
18009     if test "x$new_path" = x; then
18010       # It's still not found. Now this is an unrecoverable error.
18011       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18012 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18013       has_space=`$ECHO "$complete" | $GREP " "`
18014       if test "x$has_space" != x; then
18015         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
18016 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
18017       fi
18018       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18019     fi
18020   fi
18021 
18022   # Now new_path has a complete unix path to the binary
18023   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
18024     # Keep paths in /bin as-is, but remove trailing .exe if any
18025     new_path="${new_path/%.exe/}"
18026     # Do not save /bin paths to all_fixpath_prefixes!
18027   else
18028     # Not in mixed or Windows style, start by that.
18029     new_path=`cmd //c echo $new_path`
18030 
18031   input_path="$new_path"
18032   # Check if we need to convert this using DOS-style short mode. If the path
18033   # contains just simple characters, use it. Otherwise (spaces, weird characters),
18034   # take no chances and rewrite it.
18035   # Note: m4 eats our [], so we need to use [ and ] instead.
18036   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
18037   if test "x$has_forbidden_chars" != x; then
18038     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
18039     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
18040   fi
18041 
18042     # Output is in $new_path
18043 
18044   windows_path="$new_path"
18045   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18046     unix_path=`$CYGPATH -u "$windows_path"`
18047     new_path="$unix_path"
18048   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18049     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18050     new_path="$unix_path"
18051   fi
18052 
18053     # remove trailing .exe if any
18054     new_path="${new_path/%.exe/}"
18055 
18056     # Save the first 10 bytes of this path to the storage, so fixpath can work.
18057     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
18058   fi
18059 
18060     else
18061       # We're on a unix platform. Hooray! :)
18062       # First separate the path from the arguments. This will split at the first
18063       # space.
18064       complete="$FOUND_MAKE"
18065       path="${complete%% *}"
18066       tmp="$complete EOL"
18067       arguments="${tmp#* }"
18068 
18069       # Cannot rely on the command "which" here since it doesn't always work.
18070       is_absolute_path=`$ECHO "$path" | $GREP ^/`
18071       if test -z "$is_absolute_path"; then
18072         # Path to executable is not absolute. Find it.
18073         IFS_save="$IFS"
18074         IFS=:
18075         for p in $PATH; do
18076           if test -f "$p/$path" && test -x "$p/$path"; then
18077             new_path="$p/$path"
18078             break
18079           fi
18080         done
18081         IFS="$IFS_save"
18082       else
18083         # This is an absolute path, we can use it without further modifications.
18084         new_path="$path"
18085       fi
18086 
18087       if test "x$new_path" = x; then
18088         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18089 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18090         has_space=`$ECHO "$complete" | $GREP " "`
18091         if test "x$has_space" != x; then
18092           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
18093 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
18094         fi
18095         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18096       fi
18097     fi
18098 
18099     # Now join together the path and the arguments once again
18100     if test "x$arguments" != xEOL; then
18101       new_complete="$new_path ${arguments% *}"
18102     else
18103       new_complete="$new_path"
18104     fi
18105 
18106     if test "x$complete" != "x$new_complete"; then
18107       FOUND_MAKE="$new_complete"
18108       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
18109 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
18110     fi
18111   fi
18112 
18113         fi
18114       fi
18115     fi
18116   fi
18117 
18118         fi
18119         PATH=$OLD_PATH
18120       fi
18121     fi
18122 
18123     if test "x$FOUND_MAKE" = x; then
18124       as_fn_error $? "Cannot find GNU make $MAKE_REQUIRED_VERSION or newer! Please put it in the path, or add e.g. MAKE=/opt/gmake3.81/make as argument to configure." "$LINENO" 5
18125     fi
18126 
18127   else
18128     # The variable is set, but is it from the command line or the environment?
18129 
18130     # Try to remove the string !MAKE! from our list.
18131     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MAKE!/}
18132     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18133       # If it failed, the variable was not from the command line. Ignore it,
18134       # but warn the user (except for BASH, which is always set by the calling BASH).
18135       if test "xMAKE" != xBASH; then
18136         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MAKE from the environment. Use command line variables instead." >&5
18137 $as_echo "$as_me: WARNING: Ignoring value of MAKE from the environment. Use command line variables instead." >&2;}
18138       fi
18139       # Try to locate tool using the code snippet
18140 
18141     # Try our hardest to locate a correct version of GNU make
18142     for ac_prog in gmake
18143 do
18144   # Extract the first word of "$ac_prog", so it can be a program name with args.
18145 set dummy $ac_prog; ac_word=$2
18146 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18147 $as_echo_n "checking for $ac_word... " >&6; }
18148 if ${ac_cv_path_CHECK_GMAKE+:} false; then :
18149   $as_echo_n "(cached) " >&6
18150 else
18151   case $CHECK_GMAKE in
18152   [\\/]* | ?:[\\/]*)
18153   ac_cv_path_CHECK_GMAKE="$CHECK_GMAKE" # Let the user override the test with a path.
18154   ;;
18155   *)
18156   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18157 for as_dir in $PATH
18158 do
18159   IFS=$as_save_IFS
18160   test -z "$as_dir" && as_dir=.
18161     for ac_exec_ext in '' $ac_executable_extensions; do
18162   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18163     ac_cv_path_CHECK_GMAKE="$as_dir/$ac_word$ac_exec_ext"
18164     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18165     break 2
18166   fi
18167 done
18168   done
18169 IFS=$as_save_IFS
18170 
18171   ;;
18172 esac
18173 fi
18174 CHECK_GMAKE=$ac_cv_path_CHECK_GMAKE
18175 if test -n "$CHECK_GMAKE"; then
18176   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_GMAKE" >&5
18177 $as_echo "$CHECK_GMAKE" >&6; }
18178 else
18179   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18180 $as_echo "no" >&6; }
18181 fi
18182 
18183 
18184   test -n "$CHECK_GMAKE" && break
18185 done
18186 
18187 
18188   MAKE_CANDIDATE=""$CHECK_GMAKE""
18189   DESCRIPTION="gmake in PATH"
18190 
18191   # On Cygwin, we require a newer version of make than on other platforms
18192   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18193     MAKE_VERSION_EXPR="-e 4\."
18194     MAKE_REQUIRED_VERSION="4.0"
18195    else
18196     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
18197     MAKE_REQUIRED_VERSION="3.81"
18198   fi
18199 
18200   if test "x$MAKE_CANDIDATE" != x; then
18201     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
18202 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
18203     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
18204     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
18205     if test "x$IS_GNU_MAKE" = x; then
18206       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
18207 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
18208     else
18209       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
18210       if test "x$IS_MODERN_MAKE" = x; then
18211         { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version $MAKE_REQUIRED_VERSION or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
18212 $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version $MAKE_REQUIRED_VERSION or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
18213       else
18214         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
18215           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18216             MAKE_EXPECTED_ENV='cygwin'
18217           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18218             MAKE_EXPECTED_ENV='msys'
18219           else
18220             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
18221           fi
18222           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
18223           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
18224         else
18225           # Not relevant for non-Windows
18226           IS_MAKE_CORRECT_ENV=true
18227         fi
18228         if test "x$IS_MAKE_CORRECT_ENV" = x; then
18229           { $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
18230 $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;}
18231         else
18232           FOUND_MAKE=$MAKE_CANDIDATE
18233 
18234   # Only process if variable expands to non-empty
18235 
18236   if test "x$FOUND_MAKE" != x; then
18237     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18238 
18239   # First separate the path from the arguments. This will split at the first
18240   # space.
18241   complete="$FOUND_MAKE"
18242   path="${complete%% *}"
18243   tmp="$complete EOL"
18244   arguments="${tmp#* }"
18245 
18246   # Input might be given as Windows format, start by converting to
18247   # unix format.
18248   new_path=`$CYGPATH -u "$path"`
18249 
18250   # Now try to locate executable using which
18251   new_path=`$WHICH "$new_path" 2> /dev/null`
18252   # bat and cmd files are not always considered executable in cygwin causing which
18253   # to not find them
18254   if test "x$new_path" = x \
18255       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18256       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18257     new_path=`$CYGPATH -u "$path"`
18258   fi
18259   if test "x$new_path" = x; then
18260     # Oops. Which didn't find the executable.
18261     # The splitting of arguments from the executable at a space might have been incorrect,
18262     # since paths with space are more likely in Windows. Give it another try with the whole
18263     # argument.
18264     path="$complete"
18265     arguments="EOL"
18266     new_path=`$CYGPATH -u "$path"`
18267     new_path=`$WHICH "$new_path" 2> /dev/null`
18268     # bat and cmd files are not always considered executable in cygwin causing which
18269     # to not find them
18270     if test "x$new_path" = x \
18271         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18272         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18273       new_path=`$CYGPATH -u "$path"`
18274     fi
18275     if test "x$new_path" = x; then
18276       # It's still not found. Now this is an unrecoverable error.
18277       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18278 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18279       has_space=`$ECHO "$complete" | $GREP " "`
18280       if test "x$has_space" != x; then
18281         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
18282 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
18283       fi
18284       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18285     fi
18286   fi
18287 
18288   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
18289   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
18290   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
18291   # "foo.exe" is OK but "foo" is an error.
18292   #
18293   # This test is therefore slightly more accurate than "test -f" to check for file presence.
18294   # It is also a way to make sure we got the proper file name for the real test later on.
18295   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
18296   if test "x$test_shortpath" = x; then
18297     # Short path failed, file does not exist as specified.
18298     # Try adding .exe or .cmd
18299     if test -f "${new_path}.exe"; then
18300       input_to_shortpath="${new_path}.exe"
18301     elif test -f "${new_path}.cmd"; then
18302       input_to_shortpath="${new_path}.cmd"
18303     else
18304       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
18305 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
18306       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
18307 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
18308       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18309     fi
18310   else
18311     input_to_shortpath="$new_path"
18312   fi
18313 
18314   # Call helper function which possibly converts this using DOS-style short mode.
18315   # If so, the updated path is stored in $new_path.
18316   new_path="$input_to_shortpath"
18317 
18318   input_path="$input_to_shortpath"
18319   # Check if we need to convert this using DOS-style short mode. If the path
18320   # contains just simple characters, use it. Otherwise (spaces, weird characters),
18321   # take no chances and rewrite it.
18322   # Note: m4 eats our [], so we need to use [ and ] instead.
18323   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
18324   if test "x$has_forbidden_chars" != x; then
18325     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
18326     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
18327     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
18328     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
18329       # Going to short mode and back again did indeed matter. Since short mode is
18330       # case insensitive, let's make it lowercase to improve readability.
18331       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
18332       # Now convert it back to Unix-style (cygpath)
18333       input_path=`$CYGPATH -u "$shortmode_path"`
18334       new_path="$input_path"
18335     fi
18336   fi
18337 
18338   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
18339   if test "x$test_cygdrive_prefix" = x; then
18340     # As a simple fix, exclude /usr/bin since it's not a real path.
18341     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
18342       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
18343       # a path prefixed by /cygdrive for fixpath to work.
18344       new_path="$CYGWIN_ROOT_PATH$input_path"
18345     fi
18346   fi
18347 
18348   # remove trailing .exe if any
18349   new_path="${new_path/%.exe/}"
18350 
18351     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18352 
18353   # First separate the path from the arguments. This will split at the first
18354   # space.
18355   complete="$FOUND_MAKE"
18356   path="${complete%% *}"
18357   tmp="$complete EOL"
18358   arguments="${tmp#* }"
18359 
18360   # Input might be given as Windows format, start by converting to
18361   # unix format.
18362   new_path="$path"
18363 
18364   windows_path="$new_path"
18365   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18366     unix_path=`$CYGPATH -u "$windows_path"`
18367     new_path="$unix_path"
18368   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18369     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18370     new_path="$unix_path"
18371   fi
18372 
18373 
18374   # Now try to locate executable using which
18375   new_path=`$WHICH "$new_path" 2> /dev/null`
18376 
18377   if test "x$new_path" = x; then
18378     # Oops. Which didn't find the executable.
18379     # The splitting of arguments from the executable at a space might have been incorrect,
18380     # since paths with space are more likely in Windows. Give it another try with the whole
18381     # argument.
18382     path="$complete"
18383     arguments="EOL"
18384     new_path="$path"
18385 
18386   windows_path="$new_path"
18387   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18388     unix_path=`$CYGPATH -u "$windows_path"`
18389     new_path="$unix_path"
18390   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18391     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18392     new_path="$unix_path"
18393   fi
18394 
18395 
18396     new_path=`$WHICH "$new_path" 2> /dev/null`
18397     # bat and cmd files are not always considered executable in MSYS causing which
18398     # to not find them
18399     if test "x$new_path" = x \
18400         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18401         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18402       new_path="$path"
18403 
18404   windows_path="$new_path"
18405   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18406     unix_path=`$CYGPATH -u "$windows_path"`
18407     new_path="$unix_path"
18408   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18409     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18410     new_path="$unix_path"
18411   fi
18412 
18413     fi
18414 
18415     if test "x$new_path" = x; then
18416       # It's still not found. Now this is an unrecoverable error.
18417       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18418 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18419       has_space=`$ECHO "$complete" | $GREP " "`
18420       if test "x$has_space" != x; then
18421         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
18422 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
18423       fi
18424       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18425     fi
18426   fi
18427 
18428   # Now new_path has a complete unix path to the binary
18429   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
18430     # Keep paths in /bin as-is, but remove trailing .exe if any
18431     new_path="${new_path/%.exe/}"
18432     # Do not save /bin paths to all_fixpath_prefixes!
18433   else
18434     # Not in mixed or Windows style, start by that.
18435     new_path=`cmd //c echo $new_path`
18436 
18437   input_path="$new_path"
18438   # Check if we need to convert this using DOS-style short mode. If the path
18439   # contains just simple characters, use it. Otherwise (spaces, weird characters),
18440   # take no chances and rewrite it.
18441   # Note: m4 eats our [], so we need to use [ and ] instead.
18442   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
18443   if test "x$has_forbidden_chars" != x; then
18444     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
18445     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
18446   fi
18447 
18448     # Output is in $new_path
18449 
18450   windows_path="$new_path"
18451   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18452     unix_path=`$CYGPATH -u "$windows_path"`
18453     new_path="$unix_path"
18454   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18455     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18456     new_path="$unix_path"
18457   fi
18458 
18459     # remove trailing .exe if any
18460     new_path="${new_path/%.exe/}"
18461 
18462     # Save the first 10 bytes of this path to the storage, so fixpath can work.
18463     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
18464   fi
18465 
18466     else
18467       # We're on a unix platform. Hooray! :)
18468       # First separate the path from the arguments. This will split at the first
18469       # space.
18470       complete="$FOUND_MAKE"
18471       path="${complete%% *}"
18472       tmp="$complete EOL"
18473       arguments="${tmp#* }"
18474 
18475       # Cannot rely on the command "which" here since it doesn't always work.
18476       is_absolute_path=`$ECHO "$path" | $GREP ^/`
18477       if test -z "$is_absolute_path"; then
18478         # Path to executable is not absolute. Find it.
18479         IFS_save="$IFS"
18480         IFS=:
18481         for p in $PATH; do
18482           if test -f "$p/$path" && test -x "$p/$path"; then
18483             new_path="$p/$path"
18484             break
18485           fi
18486         done
18487         IFS="$IFS_save"
18488       else
18489         # This is an absolute path, we can use it without further modifications.
18490         new_path="$path"
18491       fi
18492 
18493       if test "x$new_path" = x; then
18494         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18495 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18496         has_space=`$ECHO "$complete" | $GREP " "`
18497         if test "x$has_space" != x; then
18498           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
18499 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
18500         fi
18501         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18502       fi
18503     fi
18504 
18505     # Now join together the path and the arguments once again
18506     if test "x$arguments" != xEOL; then
18507       new_complete="$new_path ${arguments% *}"
18508     else
18509       new_complete="$new_path"
18510     fi
18511 
18512     if test "x$complete" != "x$new_complete"; then
18513       FOUND_MAKE="$new_complete"
18514       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
18515 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
18516     fi
18517   fi
18518 
18519         fi
18520       fi
18521     fi
18522   fi
18523 
18524 
18525     if test "x$FOUND_MAKE" = x; then
18526       for ac_prog in make
18527 do
18528   # Extract the first word of "$ac_prog", so it can be a program name with args.
18529 set dummy $ac_prog; ac_word=$2
18530 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18531 $as_echo_n "checking for $ac_word... " >&6; }
18532 if ${ac_cv_path_CHECK_MAKE+:} false; then :
18533   $as_echo_n "(cached) " >&6
18534 else
18535   case $CHECK_MAKE in
18536   [\\/]* | ?:[\\/]*)
18537   ac_cv_path_CHECK_MAKE="$CHECK_MAKE" # Let the user override the test with a path.
18538   ;;
18539   *)
18540   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18541 for as_dir in $PATH
18542 do
18543   IFS=$as_save_IFS
18544   test -z "$as_dir" && as_dir=.
18545     for ac_exec_ext in '' $ac_executable_extensions; do
18546   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18547     ac_cv_path_CHECK_MAKE="$as_dir/$ac_word$ac_exec_ext"
18548     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18549     break 2
18550   fi
18551 done
18552   done
18553 IFS=$as_save_IFS
18554 
18555   ;;
18556 esac
18557 fi
18558 CHECK_MAKE=$ac_cv_path_CHECK_MAKE
18559 if test -n "$CHECK_MAKE"; then
18560   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_MAKE" >&5
18561 $as_echo "$CHECK_MAKE" >&6; }
18562 else
18563   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18564 $as_echo "no" >&6; }
18565 fi
18566 
18567 
18568   test -n "$CHECK_MAKE" && break
18569 done
18570 
18571 
18572   MAKE_CANDIDATE=""$CHECK_MAKE""
18573   DESCRIPTION="make in PATH"
18574 
18575   # On Cygwin, we require a newer version of make than on other platforms
18576   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18577     MAKE_VERSION_EXPR="-e 4\."
18578     MAKE_REQUIRED_VERSION="4.0"
18579    else
18580     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
18581     MAKE_REQUIRED_VERSION="3.81"
18582   fi
18583 
18584   if test "x$MAKE_CANDIDATE" != x; then
18585     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
18586 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
18587     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
18588     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
18589     if test "x$IS_GNU_MAKE" = x; then
18590       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
18591 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
18592     else
18593       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
18594       if test "x$IS_MODERN_MAKE" = x; then
18595         { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version $MAKE_REQUIRED_VERSION or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
18596 $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version $MAKE_REQUIRED_VERSION or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
18597       else
18598         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
18599           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18600             MAKE_EXPECTED_ENV='cygwin'
18601           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18602             MAKE_EXPECTED_ENV='msys'
18603           else
18604             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
18605           fi
18606           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
18607           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
18608         else
18609           # Not relevant for non-Windows
18610           IS_MAKE_CORRECT_ENV=true
18611         fi
18612         if test "x$IS_MAKE_CORRECT_ENV" = x; then
18613           { $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
18614 $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;}
18615         else
18616           FOUND_MAKE=$MAKE_CANDIDATE
18617 
18618   # Only process if variable expands to non-empty
18619 
18620   if test "x$FOUND_MAKE" != x; then
18621     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18622 
18623   # First separate the path from the arguments. This will split at the first
18624   # space.
18625   complete="$FOUND_MAKE"
18626   path="${complete%% *}"
18627   tmp="$complete EOL"
18628   arguments="${tmp#* }"
18629 
18630   # Input might be given as Windows format, start by converting to
18631   # unix format.
18632   new_path=`$CYGPATH -u "$path"`
18633 
18634   # Now try to locate executable using which
18635   new_path=`$WHICH "$new_path" 2> /dev/null`
18636   # bat and cmd files are not always considered executable in cygwin causing which
18637   # to not find them
18638   if test "x$new_path" = x \
18639       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18640       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18641     new_path=`$CYGPATH -u "$path"`
18642   fi
18643   if test "x$new_path" = x; then
18644     # Oops. Which didn't find the executable.
18645     # The splitting of arguments from the executable at a space might have been incorrect,
18646     # since paths with space are more likely in Windows. Give it another try with the whole
18647     # argument.
18648     path="$complete"
18649     arguments="EOL"
18650     new_path=`$CYGPATH -u "$path"`
18651     new_path=`$WHICH "$new_path" 2> /dev/null`
18652     # bat and cmd files are not always considered executable in cygwin causing which
18653     # to not find them
18654     if test "x$new_path" = x \
18655         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18656         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18657       new_path=`$CYGPATH -u "$path"`
18658     fi
18659     if test "x$new_path" = x; then
18660       # It's still not found. Now this is an unrecoverable error.
18661       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18662 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18663       has_space=`$ECHO "$complete" | $GREP " "`
18664       if test "x$has_space" != x; then
18665         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
18666 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
18667       fi
18668       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18669     fi
18670   fi
18671 
18672   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
18673   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
18674   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
18675   # "foo.exe" is OK but "foo" is an error.
18676   #
18677   # This test is therefore slightly more accurate than "test -f" to check for file presence.
18678   # It is also a way to make sure we got the proper file name for the real test later on.
18679   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
18680   if test "x$test_shortpath" = x; then
18681     # Short path failed, file does not exist as specified.
18682     # Try adding .exe or .cmd
18683     if test -f "${new_path}.exe"; then
18684       input_to_shortpath="${new_path}.exe"
18685     elif test -f "${new_path}.cmd"; then
18686       input_to_shortpath="${new_path}.cmd"
18687     else
18688       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
18689 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
18690       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
18691 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
18692       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18693     fi
18694   else
18695     input_to_shortpath="$new_path"
18696   fi
18697 
18698   # Call helper function which possibly converts this using DOS-style short mode.
18699   # If so, the updated path is stored in $new_path.
18700   new_path="$input_to_shortpath"
18701 
18702   input_path="$input_to_shortpath"
18703   # Check if we need to convert this using DOS-style short mode. If the path
18704   # contains just simple characters, use it. Otherwise (spaces, weird characters),
18705   # take no chances and rewrite it.
18706   # Note: m4 eats our [], so we need to use [ and ] instead.
18707   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
18708   if test "x$has_forbidden_chars" != x; then
18709     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
18710     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
18711     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
18712     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
18713       # Going to short mode and back again did indeed matter. Since short mode is
18714       # case insensitive, let's make it lowercase to improve readability.
18715       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
18716       # Now convert it back to Unix-style (cygpath)
18717       input_path=`$CYGPATH -u "$shortmode_path"`
18718       new_path="$input_path"
18719     fi
18720   fi
18721 
18722   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
18723   if test "x$test_cygdrive_prefix" = x; then
18724     # As a simple fix, exclude /usr/bin since it's not a real path.
18725     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
18726       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
18727       # a path prefixed by /cygdrive for fixpath to work.
18728       new_path="$CYGWIN_ROOT_PATH$input_path"
18729     fi
18730   fi
18731 
18732   # remove trailing .exe if any
18733   new_path="${new_path/%.exe/}"
18734 
18735     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18736 
18737   # First separate the path from the arguments. This will split at the first
18738   # space.
18739   complete="$FOUND_MAKE"
18740   path="${complete%% *}"
18741   tmp="$complete EOL"
18742   arguments="${tmp#* }"
18743 
18744   # Input might be given as Windows format, start by converting to
18745   # unix format.
18746   new_path="$path"
18747 
18748   windows_path="$new_path"
18749   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18750     unix_path=`$CYGPATH -u "$windows_path"`
18751     new_path="$unix_path"
18752   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18753     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18754     new_path="$unix_path"
18755   fi
18756 
18757 
18758   # Now try to locate executable using which
18759   new_path=`$WHICH "$new_path" 2> /dev/null`
18760 
18761   if test "x$new_path" = x; then
18762     # Oops. Which didn't find the executable.
18763     # The splitting of arguments from the executable at a space might have been incorrect,
18764     # since paths with space are more likely in Windows. Give it another try with the whole
18765     # argument.
18766     path="$complete"
18767     arguments="EOL"
18768     new_path="$path"
18769 
18770   windows_path="$new_path"
18771   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18772     unix_path=`$CYGPATH -u "$windows_path"`
18773     new_path="$unix_path"
18774   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18775     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18776     new_path="$unix_path"
18777   fi
18778 
18779 
18780     new_path=`$WHICH "$new_path" 2> /dev/null`
18781     # bat and cmd files are not always considered executable in MSYS causing which
18782     # to not find them
18783     if test "x$new_path" = x \
18784         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18785         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18786       new_path="$path"
18787 
18788   windows_path="$new_path"
18789   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18790     unix_path=`$CYGPATH -u "$windows_path"`
18791     new_path="$unix_path"
18792   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18793     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18794     new_path="$unix_path"
18795   fi
18796 
18797     fi
18798 
18799     if test "x$new_path" = x; then
18800       # It's still not found. Now this is an unrecoverable error.
18801       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18802 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18803       has_space=`$ECHO "$complete" | $GREP " "`
18804       if test "x$has_space" != x; then
18805         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
18806 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
18807       fi
18808       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18809     fi
18810   fi
18811 
18812   # Now new_path has a complete unix path to the binary
18813   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
18814     # Keep paths in /bin as-is, but remove trailing .exe if any
18815     new_path="${new_path/%.exe/}"
18816     # Do not save /bin paths to all_fixpath_prefixes!
18817   else
18818     # Not in mixed or Windows style, start by that.
18819     new_path=`cmd //c echo $new_path`
18820 
18821   input_path="$new_path"
18822   # Check if we need to convert this using DOS-style short mode. If the path
18823   # contains just simple characters, use it. Otherwise (spaces, weird characters),
18824   # take no chances and rewrite it.
18825   # Note: m4 eats our [], so we need to use [ and ] instead.
18826   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
18827   if test "x$has_forbidden_chars" != x; then
18828     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
18829     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
18830   fi
18831 
18832     # Output is in $new_path
18833 
18834   windows_path="$new_path"
18835   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18836     unix_path=`$CYGPATH -u "$windows_path"`
18837     new_path="$unix_path"
18838   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18839     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18840     new_path="$unix_path"
18841   fi
18842 
18843     # remove trailing .exe if any
18844     new_path="${new_path/%.exe/}"
18845 
18846     # Save the first 10 bytes of this path to the storage, so fixpath can work.
18847     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
18848   fi
18849 
18850     else
18851       # We're on a unix platform. Hooray! :)
18852       # First separate the path from the arguments. This will split at the first
18853       # space.
18854       complete="$FOUND_MAKE"
18855       path="${complete%% *}"
18856       tmp="$complete EOL"
18857       arguments="${tmp#* }"
18858 
18859       # Cannot rely on the command "which" here since it doesn't always work.
18860       is_absolute_path=`$ECHO "$path" | $GREP ^/`
18861       if test -z "$is_absolute_path"; then
18862         # Path to executable is not absolute. Find it.
18863         IFS_save="$IFS"
18864         IFS=:
18865         for p in $PATH; do
18866           if test -f "$p/$path" && test -x "$p/$path"; then
18867             new_path="$p/$path"
18868             break
18869           fi
18870         done
18871         IFS="$IFS_save"
18872       else
18873         # This is an absolute path, we can use it without further modifications.
18874         new_path="$path"
18875       fi
18876 
18877       if test "x$new_path" = x; then
18878         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18879 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18880         has_space=`$ECHO "$complete" | $GREP " "`
18881         if test "x$has_space" != x; then
18882           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
18883 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
18884         fi
18885         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18886       fi
18887     fi
18888 
18889     # Now join together the path and the arguments once again
18890     if test "x$arguments" != xEOL; then
18891       new_complete="$new_path ${arguments% *}"
18892     else
18893       new_complete="$new_path"
18894     fi
18895 
18896     if test "x$complete" != "x$new_complete"; then
18897       FOUND_MAKE="$new_complete"
18898       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
18899 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
18900     fi
18901   fi
18902 
18903         fi
18904       fi
18905     fi
18906   fi
18907 
18908     fi
18909 
18910     if test "x$FOUND_MAKE" = x; then
18911       if test "x$TOOLCHAIN_PATH" != x; then
18912         # We have a toolchain path, check that as well before giving up.
18913         OLD_PATH=$PATH
18914         PATH=$TOOLCHAIN_PATH:$PATH
18915         for ac_prog in gmake
18916 do
18917   # Extract the first word of "$ac_prog", so it can be a program name with args.
18918 set dummy $ac_prog; ac_word=$2
18919 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18920 $as_echo_n "checking for $ac_word... " >&6; }
18921 if ${ac_cv_path_CHECK_TOOLSDIR_GMAKE+:} false; then :
18922   $as_echo_n "(cached) " >&6
18923 else
18924   case $CHECK_TOOLSDIR_GMAKE in
18925   [\\/]* | ?:[\\/]*)
18926   ac_cv_path_CHECK_TOOLSDIR_GMAKE="$CHECK_TOOLSDIR_GMAKE" # Let the user override the test with a path.
18927   ;;
18928   *)
18929   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18930 for as_dir in $PATH
18931 do
18932   IFS=$as_save_IFS
18933   test -z "$as_dir" && as_dir=.
18934     for ac_exec_ext in '' $ac_executable_extensions; do
18935   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18936     ac_cv_path_CHECK_TOOLSDIR_GMAKE="$as_dir/$ac_word$ac_exec_ext"
18937     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18938     break 2
18939   fi
18940 done
18941   done
18942 IFS=$as_save_IFS
18943 
18944   ;;
18945 esac
18946 fi
18947 CHECK_TOOLSDIR_GMAKE=$ac_cv_path_CHECK_TOOLSDIR_GMAKE
18948 if test -n "$CHECK_TOOLSDIR_GMAKE"; then
18949   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_GMAKE" >&5
18950 $as_echo "$CHECK_TOOLSDIR_GMAKE" >&6; }
18951 else
18952   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18953 $as_echo "no" >&6; }
18954 fi
18955 
18956 
18957   test -n "$CHECK_TOOLSDIR_GMAKE" && break
18958 done
18959 
18960 
18961   MAKE_CANDIDATE=""$CHECK_TOOLSDIR_GMAKE""
18962   DESCRIPTION="gmake in tools-dir"
18963 
18964   # On Cygwin, we require a newer version of make than on other platforms
18965   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18966     MAKE_VERSION_EXPR="-e 4\."
18967     MAKE_REQUIRED_VERSION="4.0"
18968    else
18969     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
18970     MAKE_REQUIRED_VERSION="3.81"
18971   fi
18972 
18973   if test "x$MAKE_CANDIDATE" != x; then
18974     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
18975 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
18976     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
18977     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
18978     if test "x$IS_GNU_MAKE" = x; then
18979       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
18980 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
18981     else
18982       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
18983       if test "x$IS_MODERN_MAKE" = x; then
18984         { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version $MAKE_REQUIRED_VERSION or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
18985 $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version $MAKE_REQUIRED_VERSION or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
18986       else
18987         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
18988           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18989             MAKE_EXPECTED_ENV='cygwin'
18990           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18991             MAKE_EXPECTED_ENV='msys'
18992           else
18993             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
18994           fi
18995           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
18996           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
18997         else
18998           # Not relevant for non-Windows
18999           IS_MAKE_CORRECT_ENV=true
19000         fi
19001         if test "x$IS_MAKE_CORRECT_ENV" = x; then
19002           { $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
19003 $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;}
19004         else
19005           FOUND_MAKE=$MAKE_CANDIDATE
19006 
19007   # Only process if variable expands to non-empty
19008 
19009   if test "x$FOUND_MAKE" != x; then
19010     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19011 
19012   # First separate the path from the arguments. This will split at the first
19013   # space.
19014   complete="$FOUND_MAKE"
19015   path="${complete%% *}"
19016   tmp="$complete EOL"
19017   arguments="${tmp#* }"
19018 
19019   # Input might be given as Windows format, start by converting to
19020   # unix format.
19021   new_path=`$CYGPATH -u "$path"`
19022 
19023   # Now try to locate executable using which
19024   new_path=`$WHICH "$new_path" 2> /dev/null`
19025   # bat and cmd files are not always considered executable in cygwin causing which
19026   # to not find them
19027   if test "x$new_path" = x \
19028       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19029       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19030     new_path=`$CYGPATH -u "$path"`
19031   fi
19032   if test "x$new_path" = x; then
19033     # Oops. Which didn't find the executable.
19034     # The splitting of arguments from the executable at a space might have been incorrect,
19035     # since paths with space are more likely in Windows. Give it another try with the whole
19036     # argument.
19037     path="$complete"
19038     arguments="EOL"
19039     new_path=`$CYGPATH -u "$path"`
19040     new_path=`$WHICH "$new_path" 2> /dev/null`
19041     # bat and cmd files are not always considered executable in cygwin causing which
19042     # to not find them
19043     if test "x$new_path" = x \
19044         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19045         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19046       new_path=`$CYGPATH -u "$path"`
19047     fi
19048     if test "x$new_path" = x; then
19049       # It's still not found. Now this is an unrecoverable error.
19050       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19051 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19052       has_space=`$ECHO "$complete" | $GREP " "`
19053       if test "x$has_space" != x; then
19054         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
19055 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
19056       fi
19057       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19058     fi
19059   fi
19060 
19061   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
19062   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
19063   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
19064   # "foo.exe" is OK but "foo" is an error.
19065   #
19066   # This test is therefore slightly more accurate than "test -f" to check for file presence.
19067   # It is also a way to make sure we got the proper file name for the real test later on.
19068   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
19069   if test "x$test_shortpath" = x; then
19070     # Short path failed, file does not exist as specified.
19071     # Try adding .exe or .cmd
19072     if test -f "${new_path}.exe"; then
19073       input_to_shortpath="${new_path}.exe"
19074     elif test -f "${new_path}.cmd"; then
19075       input_to_shortpath="${new_path}.cmd"
19076     else
19077       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
19078 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
19079       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
19080 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
19081       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19082     fi
19083   else
19084     input_to_shortpath="$new_path"
19085   fi
19086 
19087   # Call helper function which possibly converts this using DOS-style short mode.
19088   # If so, the updated path is stored in $new_path.
19089   new_path="$input_to_shortpath"
19090 
19091   input_path="$input_to_shortpath"
19092   # Check if we need to convert this using DOS-style short mode. If the path
19093   # contains just simple characters, use it. Otherwise (spaces, weird characters),
19094   # take no chances and rewrite it.
19095   # Note: m4 eats our [], so we need to use [ and ] instead.
19096   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
19097   if test "x$has_forbidden_chars" != x; then
19098     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
19099     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
19100     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
19101     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
19102       # Going to short mode and back again did indeed matter. Since short mode is
19103       # case insensitive, let's make it lowercase to improve readability.
19104       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
19105       # Now convert it back to Unix-style (cygpath)
19106       input_path=`$CYGPATH -u "$shortmode_path"`
19107       new_path="$input_path"
19108     fi
19109   fi
19110 
19111   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
19112   if test "x$test_cygdrive_prefix" = x; then
19113     # As a simple fix, exclude /usr/bin since it's not a real path.
19114     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
19115       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
19116       # a path prefixed by /cygdrive for fixpath to work.
19117       new_path="$CYGWIN_ROOT_PATH$input_path"
19118     fi
19119   fi
19120 
19121   # remove trailing .exe if any
19122   new_path="${new_path/%.exe/}"
19123 
19124     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19125 
19126   # First separate the path from the arguments. This will split at the first
19127   # space.
19128   complete="$FOUND_MAKE"
19129   path="${complete%% *}"
19130   tmp="$complete EOL"
19131   arguments="${tmp#* }"
19132 
19133   # Input might be given as Windows format, start by converting to
19134   # unix format.
19135   new_path="$path"
19136 
19137   windows_path="$new_path"
19138   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19139     unix_path=`$CYGPATH -u "$windows_path"`
19140     new_path="$unix_path"
19141   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19142     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19143     new_path="$unix_path"
19144   fi
19145 
19146 
19147   # Now try to locate executable using which
19148   new_path=`$WHICH "$new_path" 2> /dev/null`
19149 
19150   if test "x$new_path" = x; then
19151     # Oops. Which didn't find the executable.
19152     # The splitting of arguments from the executable at a space might have been incorrect,
19153     # since paths with space are more likely in Windows. Give it another try with the whole
19154     # argument.
19155     path="$complete"
19156     arguments="EOL"
19157     new_path="$path"
19158 
19159   windows_path="$new_path"
19160   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19161     unix_path=`$CYGPATH -u "$windows_path"`
19162     new_path="$unix_path"
19163   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19164     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19165     new_path="$unix_path"
19166   fi
19167 
19168 
19169     new_path=`$WHICH "$new_path" 2> /dev/null`
19170     # bat and cmd files are not always considered executable in MSYS causing which
19171     # to not find them
19172     if test "x$new_path" = x \
19173         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19174         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19175       new_path="$path"
19176 
19177   windows_path="$new_path"
19178   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19179     unix_path=`$CYGPATH -u "$windows_path"`
19180     new_path="$unix_path"
19181   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19182     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19183     new_path="$unix_path"
19184   fi
19185 
19186     fi
19187 
19188     if test "x$new_path" = x; then
19189       # It's still not found. Now this is an unrecoverable error.
19190       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19191 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19192       has_space=`$ECHO "$complete" | $GREP " "`
19193       if test "x$has_space" != x; then
19194         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
19195 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
19196       fi
19197       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19198     fi
19199   fi
19200 
19201   # Now new_path has a complete unix path to the binary
19202   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
19203     # Keep paths in /bin as-is, but remove trailing .exe if any
19204     new_path="${new_path/%.exe/}"
19205     # Do not save /bin paths to all_fixpath_prefixes!
19206   else
19207     # Not in mixed or Windows style, start by that.
19208     new_path=`cmd //c echo $new_path`
19209 
19210   input_path="$new_path"
19211   # Check if we need to convert this using DOS-style short mode. If the path
19212   # contains just simple characters, use it. Otherwise (spaces, weird characters),
19213   # take no chances and rewrite it.
19214   # Note: m4 eats our [], so we need to use [ and ] instead.
19215   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
19216   if test "x$has_forbidden_chars" != x; then
19217     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
19218     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
19219   fi
19220 
19221     # Output is in $new_path
19222 
19223   windows_path="$new_path"
19224   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19225     unix_path=`$CYGPATH -u "$windows_path"`
19226     new_path="$unix_path"
19227   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19228     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19229     new_path="$unix_path"
19230   fi
19231 
19232     # remove trailing .exe if any
19233     new_path="${new_path/%.exe/}"
19234 
19235     # Save the first 10 bytes of this path to the storage, so fixpath can work.
19236     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
19237   fi
19238 
19239     else
19240       # We're on a unix platform. Hooray! :)
19241       # First separate the path from the arguments. This will split at the first
19242       # space.
19243       complete="$FOUND_MAKE"
19244       path="${complete%% *}"
19245       tmp="$complete EOL"
19246       arguments="${tmp#* }"
19247 
19248       # Cannot rely on the command "which" here since it doesn't always work.
19249       is_absolute_path=`$ECHO "$path" | $GREP ^/`
19250       if test -z "$is_absolute_path"; then
19251         # Path to executable is not absolute. Find it.
19252         IFS_save="$IFS"
19253         IFS=:
19254         for p in $PATH; do
19255           if test -f "$p/$path" && test -x "$p/$path"; then
19256             new_path="$p/$path"
19257             break
19258           fi
19259         done
19260         IFS="$IFS_save"
19261       else
19262         # This is an absolute path, we can use it without further modifications.
19263         new_path="$path"
19264       fi
19265 
19266       if test "x$new_path" = x; then
19267         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19268 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19269         has_space=`$ECHO "$complete" | $GREP " "`
19270         if test "x$has_space" != x; then
19271           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
19272 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
19273         fi
19274         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19275       fi
19276     fi
19277 
19278     # Now join together the path and the arguments once again
19279     if test "x$arguments" != xEOL; then
19280       new_complete="$new_path ${arguments% *}"
19281     else
19282       new_complete="$new_path"
19283     fi
19284 
19285     if test "x$complete" != "x$new_complete"; then
19286       FOUND_MAKE="$new_complete"
19287       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
19288 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
19289     fi
19290   fi
19291 
19292         fi
19293       fi
19294     fi
19295   fi
19296 
19297         if test "x$FOUND_MAKE" = x; then
19298           for ac_prog in make
19299 do
19300   # Extract the first word of "$ac_prog", so it can be a program name with args.
19301 set dummy $ac_prog; ac_word=$2
19302 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19303 $as_echo_n "checking for $ac_word... " >&6; }
19304 if ${ac_cv_path_CHECK_TOOLSDIR_MAKE+:} false; then :
19305   $as_echo_n "(cached) " >&6
19306 else
19307   case $CHECK_TOOLSDIR_MAKE in
19308   [\\/]* | ?:[\\/]*)
19309   ac_cv_path_CHECK_TOOLSDIR_MAKE="$CHECK_TOOLSDIR_MAKE" # Let the user override the test with a path.
19310   ;;
19311   *)
19312   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19313 for as_dir in $PATH
19314 do
19315   IFS=$as_save_IFS
19316   test -z "$as_dir" && as_dir=.
19317     for ac_exec_ext in '' $ac_executable_extensions; do
19318   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19319     ac_cv_path_CHECK_TOOLSDIR_MAKE="$as_dir/$ac_word$ac_exec_ext"
19320     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19321     break 2
19322   fi
19323 done
19324   done
19325 IFS=$as_save_IFS
19326 
19327   ;;
19328 esac
19329 fi
19330 CHECK_TOOLSDIR_MAKE=$ac_cv_path_CHECK_TOOLSDIR_MAKE
19331 if test -n "$CHECK_TOOLSDIR_MAKE"; then
19332   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_MAKE" >&5
19333 $as_echo "$CHECK_TOOLSDIR_MAKE" >&6; }
19334 else
19335   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19336 $as_echo "no" >&6; }
19337 fi
19338 
19339 
19340   test -n "$CHECK_TOOLSDIR_MAKE" && break
19341 done
19342 
19343 
19344   MAKE_CANDIDATE=""$CHECK_TOOLSDIR_MAKE""
19345   DESCRIPTION="make in tools-dir"
19346 
19347   # On Cygwin, we require a newer version of make than on other platforms
19348   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19349     MAKE_VERSION_EXPR="-e 4\."
19350     MAKE_REQUIRED_VERSION="4.0"
19351    else
19352     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
19353     MAKE_REQUIRED_VERSION="3.81"
19354   fi
19355 
19356   if test "x$MAKE_CANDIDATE" != x; then
19357     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
19358 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
19359     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
19360     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
19361     if test "x$IS_GNU_MAKE" = x; then
19362       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
19363 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
19364     else
19365       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
19366       if test "x$IS_MODERN_MAKE" = x; then
19367         { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version $MAKE_REQUIRED_VERSION or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
19368 $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version $MAKE_REQUIRED_VERSION or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
19369       else
19370         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
19371           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19372             MAKE_EXPECTED_ENV='cygwin'
19373           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19374             MAKE_EXPECTED_ENV='msys'
19375           else
19376             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
19377           fi
19378           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
19379           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
19380         else
19381           # Not relevant for non-Windows
19382           IS_MAKE_CORRECT_ENV=true
19383         fi
19384         if test "x$IS_MAKE_CORRECT_ENV" = x; then
19385           { $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
19386 $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;}
19387         else
19388           FOUND_MAKE=$MAKE_CANDIDATE
19389 
19390   # Only process if variable expands to non-empty
19391 
19392   if test "x$FOUND_MAKE" != x; then
19393     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19394 
19395   # First separate the path from the arguments. This will split at the first
19396   # space.
19397   complete="$FOUND_MAKE"
19398   path="${complete%% *}"
19399   tmp="$complete EOL"
19400   arguments="${tmp#* }"
19401 
19402   # Input might be given as Windows format, start by converting to
19403   # unix format.
19404   new_path=`$CYGPATH -u "$path"`
19405 
19406   # Now try to locate executable using which
19407   new_path=`$WHICH "$new_path" 2> /dev/null`
19408   # bat and cmd files are not always considered executable in cygwin causing which
19409   # to not find them
19410   if test "x$new_path" = x \
19411       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19412       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19413     new_path=`$CYGPATH -u "$path"`
19414   fi
19415   if test "x$new_path" = x; then
19416     # Oops. Which didn't find the executable.
19417     # The splitting of arguments from the executable at a space might have been incorrect,
19418     # since paths with space are more likely in Windows. Give it another try with the whole
19419     # argument.
19420     path="$complete"
19421     arguments="EOL"
19422     new_path=`$CYGPATH -u "$path"`
19423     new_path=`$WHICH "$new_path" 2> /dev/null`
19424     # bat and cmd files are not always considered executable in cygwin causing which
19425     # to not find them
19426     if test "x$new_path" = x \
19427         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19428         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19429       new_path=`$CYGPATH -u "$path"`
19430     fi
19431     if test "x$new_path" = x; then
19432       # It's still not found. Now this is an unrecoverable error.
19433       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19434 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19435       has_space=`$ECHO "$complete" | $GREP " "`
19436       if test "x$has_space" != x; then
19437         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
19438 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
19439       fi
19440       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19441     fi
19442   fi
19443 
19444   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
19445   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
19446   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
19447   # "foo.exe" is OK but "foo" is an error.
19448   #
19449   # This test is therefore slightly more accurate than "test -f" to check for file presence.
19450   # It is also a way to make sure we got the proper file name for the real test later on.
19451   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
19452   if test "x$test_shortpath" = x; then
19453     # Short path failed, file does not exist as specified.
19454     # Try adding .exe or .cmd
19455     if test -f "${new_path}.exe"; then
19456       input_to_shortpath="${new_path}.exe"
19457     elif test -f "${new_path}.cmd"; then
19458       input_to_shortpath="${new_path}.cmd"
19459     else
19460       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
19461 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
19462       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
19463 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
19464       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19465     fi
19466   else
19467     input_to_shortpath="$new_path"
19468   fi
19469 
19470   # Call helper function which possibly converts this using DOS-style short mode.
19471   # If so, the updated path is stored in $new_path.
19472   new_path="$input_to_shortpath"
19473 
19474   input_path="$input_to_shortpath"
19475   # Check if we need to convert this using DOS-style short mode. If the path
19476   # contains just simple characters, use it. Otherwise (spaces, weird characters),
19477   # take no chances and rewrite it.
19478   # Note: m4 eats our [], so we need to use [ and ] instead.
19479   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
19480   if test "x$has_forbidden_chars" != x; then
19481     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
19482     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
19483     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
19484     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
19485       # Going to short mode and back again did indeed matter. Since short mode is
19486       # case insensitive, let's make it lowercase to improve readability.
19487       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
19488       # Now convert it back to Unix-style (cygpath)
19489       input_path=`$CYGPATH -u "$shortmode_path"`
19490       new_path="$input_path"
19491     fi
19492   fi
19493 
19494   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
19495   if test "x$test_cygdrive_prefix" = x; then
19496     # As a simple fix, exclude /usr/bin since it's not a real path.
19497     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
19498       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
19499       # a path prefixed by /cygdrive for fixpath to work.
19500       new_path="$CYGWIN_ROOT_PATH$input_path"
19501     fi
19502   fi
19503 
19504   # remove trailing .exe if any
19505   new_path="${new_path/%.exe/}"
19506 
19507     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19508 
19509   # First separate the path from the arguments. This will split at the first
19510   # space.
19511   complete="$FOUND_MAKE"
19512   path="${complete%% *}"
19513   tmp="$complete EOL"
19514   arguments="${tmp#* }"
19515 
19516   # Input might be given as Windows format, start by converting to
19517   # unix format.
19518   new_path="$path"
19519 
19520   windows_path="$new_path"
19521   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19522     unix_path=`$CYGPATH -u "$windows_path"`
19523     new_path="$unix_path"
19524   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19525     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19526     new_path="$unix_path"
19527   fi
19528 
19529 
19530   # Now try to locate executable using which
19531   new_path=`$WHICH "$new_path" 2> /dev/null`
19532 
19533   if test "x$new_path" = x; then
19534     # Oops. Which didn't find the executable.
19535     # The splitting of arguments from the executable at a space might have been incorrect,
19536     # since paths with space are more likely in Windows. Give it another try with the whole
19537     # argument.
19538     path="$complete"
19539     arguments="EOL"
19540     new_path="$path"
19541 
19542   windows_path="$new_path"
19543   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19544     unix_path=`$CYGPATH -u "$windows_path"`
19545     new_path="$unix_path"
19546   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19547     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19548     new_path="$unix_path"
19549   fi
19550 
19551 
19552     new_path=`$WHICH "$new_path" 2> /dev/null`
19553     # bat and cmd files are not always considered executable in MSYS causing which
19554     # to not find them
19555     if test "x$new_path" = x \
19556         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19557         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19558       new_path="$path"
19559 
19560   windows_path="$new_path"
19561   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19562     unix_path=`$CYGPATH -u "$windows_path"`
19563     new_path="$unix_path"
19564   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19565     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19566     new_path="$unix_path"
19567   fi
19568 
19569     fi
19570 
19571     if test "x$new_path" = x; then
19572       # It's still not found. Now this is an unrecoverable error.
19573       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19574 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19575       has_space=`$ECHO "$complete" | $GREP " "`
19576       if test "x$has_space" != x; then
19577         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
19578 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
19579       fi
19580       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19581     fi
19582   fi
19583 
19584   # Now new_path has a complete unix path to the binary
19585   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
19586     # Keep paths in /bin as-is, but remove trailing .exe if any
19587     new_path="${new_path/%.exe/}"
19588     # Do not save /bin paths to all_fixpath_prefixes!
19589   else
19590     # Not in mixed or Windows style, start by that.
19591     new_path=`cmd //c echo $new_path`
19592 
19593   input_path="$new_path"
19594   # Check if we need to convert this using DOS-style short mode. If the path
19595   # contains just simple characters, use it. Otherwise (spaces, weird characters),
19596   # take no chances and rewrite it.
19597   # Note: m4 eats our [], so we need to use [ and ] instead.
19598   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
19599   if test "x$has_forbidden_chars" != x; then
19600     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
19601     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
19602   fi
19603 
19604     # Output is in $new_path
19605 
19606   windows_path="$new_path"
19607   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19608     unix_path=`$CYGPATH -u "$windows_path"`
19609     new_path="$unix_path"
19610   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19611     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19612     new_path="$unix_path"
19613   fi
19614 
19615     # remove trailing .exe if any
19616     new_path="${new_path/%.exe/}"
19617 
19618     # Save the first 10 bytes of this path to the storage, so fixpath can work.
19619     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
19620   fi
19621 
19622     else
19623       # We're on a unix platform. Hooray! :)
19624       # First separate the path from the arguments. This will split at the first
19625       # space.
19626       complete="$FOUND_MAKE"
19627       path="${complete%% *}"
19628       tmp="$complete EOL"
19629       arguments="${tmp#* }"
19630 
19631       # Cannot rely on the command "which" here since it doesn't always work.
19632       is_absolute_path=`$ECHO "$path" | $GREP ^/`
19633       if test -z "$is_absolute_path"; then
19634         # Path to executable is not absolute. Find it.
19635         IFS_save="$IFS"
19636         IFS=:
19637         for p in $PATH; do
19638           if test -f "$p/$path" && test -x "$p/$path"; then
19639             new_path="$p/$path"
19640             break
19641           fi
19642         done
19643         IFS="$IFS_save"
19644       else
19645         # This is an absolute path, we can use it without further modifications.
19646         new_path="$path"
19647       fi
19648 
19649       if test "x$new_path" = x; then
19650         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19651 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19652         has_space=`$ECHO "$complete" | $GREP " "`
19653         if test "x$has_space" != x; then
19654           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
19655 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
19656         fi
19657         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19658       fi
19659     fi
19660 
19661     # Now join together the path and the arguments once again
19662     if test "x$arguments" != xEOL; then
19663       new_complete="$new_path ${arguments% *}"
19664     else
19665       new_complete="$new_path"
19666     fi
19667 
19668     if test "x$complete" != "x$new_complete"; then
19669       FOUND_MAKE="$new_complete"
19670       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
19671 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
19672     fi
19673   fi
19674 
19675         fi
19676       fi
19677     fi
19678   fi
19679 
19680         fi
19681         PATH=$OLD_PATH
19682       fi
19683     fi
19684 
19685     if test "x$FOUND_MAKE" = x; then
19686       as_fn_error $? "Cannot find GNU make $MAKE_REQUIRED_VERSION or newer! Please put it in the path, or add e.g. MAKE=/opt/gmake3.81/make as argument to configure." "$LINENO" 5
19687     fi
19688 
19689     else
19690       # If it succeeded, then it was overridden by the user. We will use it
19691       # for the tool.
19692 
19693       # First remove it from the list of overridden variables, so we can test
19694       # for unknown variables in the end.
19695       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
19696 
19697       # Check if we try to supply an empty value
19698       if test "x$MAKE" = x; then
19699         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool MAKE= (no value)" >&5
19700 $as_echo "$as_me: Setting user supplied tool MAKE= (no value)" >&6;}
19701         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MAKE" >&5
19702 $as_echo_n "checking for MAKE... " >&6; }
19703         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
19704 $as_echo "disabled" >&6; }
19705       else
19706         # Check if the provided tool contains a complete path.
19707         tool_specified="$MAKE"
19708         tool_basename="${tool_specified##*/}"
19709         if test "x$tool_basename" = "x$tool_specified"; then
19710           # A command without a complete path is provided, search $PATH.
19711           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MAKE=$tool_basename" >&5
19712 $as_echo "$as_me: Will search for user supplied tool MAKE=$tool_basename" >&6;}
19713           # Extract the first word of "$tool_basename", so it can be a program name with args.
19714 set dummy $tool_basename; ac_word=$2
19715 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19716 $as_echo_n "checking for $ac_word... " >&6; }
19717 if ${ac_cv_path_MAKE+:} false; then :
19718   $as_echo_n "(cached) " >&6
19719 else
19720   case $MAKE in
19721   [\\/]* | ?:[\\/]*)
19722   ac_cv_path_MAKE="$MAKE" # Let the user override the test with a path.
19723   ;;
19724   *)
19725   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19726 for as_dir in $PATH
19727 do
19728   IFS=$as_save_IFS
19729   test -z "$as_dir" && as_dir=.
19730     for ac_exec_ext in '' $ac_executable_extensions; do
19731   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19732     ac_cv_path_MAKE="$as_dir/$ac_word$ac_exec_ext"
19733     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19734     break 2
19735   fi
19736 done
19737   done
19738 IFS=$as_save_IFS
19739 
19740   ;;
19741 esac
19742 fi
19743 MAKE=$ac_cv_path_MAKE
19744 if test -n "$MAKE"; then
19745   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MAKE" >&5
19746 $as_echo "$MAKE" >&6; }
19747 else
19748   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19749 $as_echo "no" >&6; }
19750 fi
19751 
19752 
19753           if test "x$MAKE" = x; then
19754             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
19755           fi
19756         else
19757           # Otherwise we believe it is a complete path. Use it as it is.
19758           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MAKE=$tool_specified" >&5
19759 $as_echo "$as_me: Will use user supplied tool MAKE=$tool_specified" >&6;}
19760           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MAKE" >&5
19761 $as_echo_n "checking for MAKE... " >&6; }
19762           if test ! -x "$tool_specified"; then
19763             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
19764 $as_echo "not found" >&6; }
19765             as_fn_error $? "User supplied tool MAKE=$tool_specified does not exist or is not executable" "$LINENO" 5
19766           fi
19767           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
19768 $as_echo "$tool_specified" >&6; }
19769         fi
19770       fi
19771     fi
19772 
19773     # If MAKE was set by user, verify the version
19774 
19775   MAKE_CANDIDATE=""$MAKE""
19776   DESCRIPTION="user supplied MAKE=$MAKE"
19777 
19778   # On Cygwin, we require a newer version of make than on other platforms
19779   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19780     MAKE_VERSION_EXPR="-e 4\."
19781     MAKE_REQUIRED_VERSION="4.0"
19782    else
19783     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
19784     MAKE_REQUIRED_VERSION="3.81"
19785   fi
19786 
19787   if test "x$MAKE_CANDIDATE" != x; then
19788     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
19789 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
19790     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
19791     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
19792     if test "x$IS_GNU_MAKE" = x; then
19793       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
19794 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
19795     else
19796       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
19797       if test "x$IS_MODERN_MAKE" = x; then
19798         { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version $MAKE_REQUIRED_VERSION or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
19799 $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version $MAKE_REQUIRED_VERSION or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
19800       else
19801         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
19802           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19803             MAKE_EXPECTED_ENV='cygwin'
19804           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19805             MAKE_EXPECTED_ENV='msys'
19806           else
19807             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
19808           fi
19809           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
19810           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
19811         else
19812           # Not relevant for non-Windows
19813           IS_MAKE_CORRECT_ENV=true
19814         fi
19815         if test "x$IS_MAKE_CORRECT_ENV" = x; then
19816           { $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
19817 $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;}
19818         else
19819           FOUND_MAKE=$MAKE_CANDIDATE
19820 
19821   # Only process if variable expands to non-empty
19822 
19823   if test "x$FOUND_MAKE" != x; then
19824     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19825 
19826   # First separate the path from the arguments. This will split at the first
19827   # space.
19828   complete="$FOUND_MAKE"
19829   path="${complete%% *}"
19830   tmp="$complete EOL"
19831   arguments="${tmp#* }"
19832 
19833   # Input might be given as Windows format, start by converting to
19834   # unix format.
19835   new_path=`$CYGPATH -u "$path"`
19836 
19837   # Now try to locate executable using which
19838   new_path=`$WHICH "$new_path" 2> /dev/null`
19839   # bat and cmd files are not always considered executable in cygwin causing which
19840   # to not find them
19841   if test "x$new_path" = x \
19842       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19843       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19844     new_path=`$CYGPATH -u "$path"`
19845   fi
19846   if test "x$new_path" = x; then
19847     # Oops. Which didn't find the executable.
19848     # The splitting of arguments from the executable at a space might have been incorrect,
19849     # since paths with space are more likely in Windows. Give it another try with the whole
19850     # argument.
19851     path="$complete"
19852     arguments="EOL"
19853     new_path=`$CYGPATH -u "$path"`
19854     new_path=`$WHICH "$new_path" 2> /dev/null`
19855     # bat and cmd files are not always considered executable in cygwin causing which
19856     # to not find them
19857     if test "x$new_path" = x \
19858         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19859         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19860       new_path=`$CYGPATH -u "$path"`
19861     fi
19862     if test "x$new_path" = x; then
19863       # It's still not found. Now this is an unrecoverable error.
19864       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19865 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19866       has_space=`$ECHO "$complete" | $GREP " "`
19867       if test "x$has_space" != x; then
19868         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
19869 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
19870       fi
19871       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19872     fi
19873   fi
19874 
19875   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
19876   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
19877   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
19878   # "foo.exe" is OK but "foo" is an error.
19879   #
19880   # This test is therefore slightly more accurate than "test -f" to check for file presence.
19881   # It is also a way to make sure we got the proper file name for the real test later on.
19882   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
19883   if test "x$test_shortpath" = x; then
19884     # Short path failed, file does not exist as specified.
19885     # Try adding .exe or .cmd
19886     if test -f "${new_path}.exe"; then
19887       input_to_shortpath="${new_path}.exe"
19888     elif test -f "${new_path}.cmd"; then
19889       input_to_shortpath="${new_path}.cmd"
19890     else
19891       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
19892 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
19893       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
19894 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
19895       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19896     fi
19897   else
19898     input_to_shortpath="$new_path"
19899   fi
19900 
19901   # Call helper function which possibly converts this using DOS-style short mode.
19902   # If so, the updated path is stored in $new_path.
19903   new_path="$input_to_shortpath"
19904 
19905   input_path="$input_to_shortpath"
19906   # Check if we need to convert this using DOS-style short mode. If the path
19907   # contains just simple characters, use it. Otherwise (spaces, weird characters),
19908   # take no chances and rewrite it.
19909   # Note: m4 eats our [], so we need to use [ and ] instead.
19910   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
19911   if test "x$has_forbidden_chars" != x; then
19912     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
19913     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
19914     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
19915     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
19916       # Going to short mode and back again did indeed matter. Since short mode is
19917       # case insensitive, let's make it lowercase to improve readability.
19918       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
19919       # Now convert it back to Unix-style (cygpath)
19920       input_path=`$CYGPATH -u "$shortmode_path"`
19921       new_path="$input_path"
19922     fi
19923   fi
19924 
19925   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
19926   if test "x$test_cygdrive_prefix" = x; then
19927     # As a simple fix, exclude /usr/bin since it's not a real path.
19928     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
19929       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
19930       # a path prefixed by /cygdrive for fixpath to work.
19931       new_path="$CYGWIN_ROOT_PATH$input_path"
19932     fi
19933   fi
19934 
19935   # remove trailing .exe if any
19936   new_path="${new_path/%.exe/}"
19937 
19938     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19939 
19940   # First separate the path from the arguments. This will split at the first
19941   # space.
19942   complete="$FOUND_MAKE"
19943   path="${complete%% *}"
19944   tmp="$complete EOL"
19945   arguments="${tmp#* }"
19946 
19947   # Input might be given as Windows format, start by converting to
19948   # unix format.
19949   new_path="$path"
19950 
19951   windows_path="$new_path"
19952   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19953     unix_path=`$CYGPATH -u "$windows_path"`
19954     new_path="$unix_path"
19955   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19956     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19957     new_path="$unix_path"
19958   fi
19959 
19960 
19961   # Now try to locate executable using which
19962   new_path=`$WHICH "$new_path" 2> /dev/null`
19963 
19964   if test "x$new_path" = x; then
19965     # Oops. Which didn't find the executable.
19966     # The splitting of arguments from the executable at a space might have been incorrect,
19967     # since paths with space are more likely in Windows. Give it another try with the whole
19968     # argument.
19969     path="$complete"
19970     arguments="EOL"
19971     new_path="$path"
19972 
19973   windows_path="$new_path"
19974   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19975     unix_path=`$CYGPATH -u "$windows_path"`
19976     new_path="$unix_path"
19977   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19978     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19979     new_path="$unix_path"
19980   fi
19981 
19982 
19983     new_path=`$WHICH "$new_path" 2> /dev/null`
19984     # bat and cmd files are not always considered executable in MSYS causing which
19985     # to not find them
19986     if test "x$new_path" = x \
19987         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19988         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19989       new_path="$path"
19990 
19991   windows_path="$new_path"
19992   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19993     unix_path=`$CYGPATH -u "$windows_path"`
19994     new_path="$unix_path"
19995   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19996     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19997     new_path="$unix_path"
19998   fi
19999 
20000     fi
20001 
20002     if test "x$new_path" = x; then
20003       # It's still not found. Now this is an unrecoverable error.
20004       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
20005 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
20006       has_space=`$ECHO "$complete" | $GREP " "`
20007       if test "x$has_space" != x; then
20008         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
20009 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
20010       fi
20011       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
20012     fi
20013   fi
20014 
20015   # Now new_path has a complete unix path to the binary
20016   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
20017     # Keep paths in /bin as-is, but remove trailing .exe if any
20018     new_path="${new_path/%.exe/}"
20019     # Do not save /bin paths to all_fixpath_prefixes!
20020   else
20021     # Not in mixed or Windows style, start by that.
20022     new_path=`cmd //c echo $new_path`
20023 
20024   input_path="$new_path"
20025   # Check if we need to convert this using DOS-style short mode. If the path
20026   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20027   # take no chances and rewrite it.
20028   # Note: m4 eats our [], so we need to use [ and ] instead.
20029   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20030   if test "x$has_forbidden_chars" != x; then
20031     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20032     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20033   fi
20034 
20035     # Output is in $new_path
20036 
20037   windows_path="$new_path"
20038   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20039     unix_path=`$CYGPATH -u "$windows_path"`
20040     new_path="$unix_path"
20041   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20042     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20043     new_path="$unix_path"
20044   fi
20045 
20046     # remove trailing .exe if any
20047     new_path="${new_path/%.exe/}"
20048 
20049     # Save the first 10 bytes of this path to the storage, so fixpath can work.
20050     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20051   fi
20052 
20053     else
20054       # We're on a unix platform. Hooray! :)
20055       # First separate the path from the arguments. This will split at the first
20056       # space.
20057       complete="$FOUND_MAKE"
20058       path="${complete%% *}"
20059       tmp="$complete EOL"
20060       arguments="${tmp#* }"
20061 
20062       # Cannot rely on the command "which" here since it doesn't always work.
20063       is_absolute_path=`$ECHO "$path" | $GREP ^/`
20064       if test -z "$is_absolute_path"; then
20065         # Path to executable is not absolute. Find it.
20066         IFS_save="$IFS"
20067         IFS=:
20068         for p in $PATH; do
20069           if test -f "$p/$path" && test -x "$p/$path"; then
20070             new_path="$p/$path"
20071             break
20072           fi
20073         done
20074         IFS="$IFS_save"
20075       else
20076         # This is an absolute path, we can use it without further modifications.
20077         new_path="$path"
20078       fi
20079 
20080       if test "x$new_path" = x; then
20081         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
20082 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
20083         has_space=`$ECHO "$complete" | $GREP " "`
20084         if test "x$has_space" != x; then
20085           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
20086 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
20087         fi
20088         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
20089       fi
20090     fi
20091 
20092     # Now join together the path and the arguments once again
20093     if test "x$arguments" != xEOL; then
20094       new_complete="$new_path ${arguments% *}"
20095     else
20096       new_complete="$new_path"
20097     fi
20098 
20099     if test "x$complete" != "x$new_complete"; then
20100       FOUND_MAKE="$new_complete"
20101       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
20102 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
20103     fi
20104   fi
20105 
20106         fi
20107       fi
20108     fi
20109   fi
20110 
20111     if test "x$FOUND_MAKE" = x; then
20112       as_fn_error $? "The specified make (by MAKE=$MAKE) is not GNU make $MAKE_REQUIRED_VERSION or newer." "$LINENO" 5
20113     fi
20114 
20115   fi
20116 
20117 
20118   MAKE=$FOUND_MAKE
20119 
20120   { $as_echo "$as_me:${as_lineno-$LINENO}: Using GNU make at $FOUND_MAKE (version: $MAKE_VERSION_STRING)" >&5
20121 $as_echo "$as_me: Using GNU make at $FOUND_MAKE (version: $MAKE_VERSION_STRING)" >&6;}
20122 
20123 
20124   # Check if make supports the output sync option and if so, setup using it.
20125   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if make --output-sync is supported" >&5
20126 $as_echo_n "checking if make --output-sync is supported... " >&6; }
20127   if $MAKE --version -O > /dev/null 2>&1; then
20128     OUTPUT_SYNC_SUPPORTED=true
20129     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
20130 $as_echo "yes" >&6; }
20131     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for output-sync value" >&5
20132 $as_echo_n "checking for output-sync value... " >&6; }
20133 
20134 # Check whether --with-output-sync was given.
20135 if test "${with_output_sync+set}" = set; then :
20136   withval=$with_output_sync; OUTPUT_SYNC=$with_output_sync
20137 fi
20138 
20139     if test "x$OUTPUT_SYNC" = "x"; then
20140       OUTPUT_SYNC=none
20141     fi
20142     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OUTPUT_SYNC" >&5
20143 $as_echo "$OUTPUT_SYNC" >&6; }
20144     if ! $MAKE --version -O$OUTPUT_SYNC > /dev/null 2>&1; then
20145       as_fn_error $? "Make did not the support the value $OUTPUT_SYNC as output sync type." "$LINENO" 5
20146     fi
20147   else
20148     OUTPUT_SYNC_SUPPORTED=false
20149     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20150 $as_echo "no" >&6; }
20151   fi
20152 
20153 
20154 
20155 
20156 
20157 
20158   # Test if find supports -delete
20159   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if find supports -delete" >&5
20160 $as_echo_n "checking if find supports -delete... " >&6; }
20161   FIND_DELETE="-delete"
20162 
20163   DELETEDIR=`$MKTEMP -d tmp.XXXXXXXXXX` || (echo Could not create temporary directory!; exit $?)
20164 
20165   echo Hejsan > $DELETEDIR/TestIfFindSupportsDelete
20166 
20167   TEST_DELETE=`$FIND "$DELETEDIR" -name TestIfFindSupportsDelete $FIND_DELETE 2>&1`
20168   if test -f $DELETEDIR/TestIfFindSupportsDelete; then
20169     # No, it does not.
20170     rm $DELETEDIR/TestIfFindSupportsDelete
20171     if test "x$OPENJDK_TARGET_OS" = "xaix"; then
20172       # AIX 'find' is buggy if called with '-exec {} \+' and an empty file list
20173       FIND_DELETE="-print | xargs rm"
20174     else
20175       FIND_DELETE="-exec rm \{\} \+"
20176     fi
20177     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20178 $as_echo "no" >&6; }
20179   else
20180     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
20181 $as_echo "yes" >&6; }
20182   fi
20183   rmdir $DELETEDIR
20184 
20185 
20186 
20187   # These tools might not be installed by default,
20188   # need hint on how to install them.
20189 
20190 
20191 
20192   # Publish this variable in the help.
20193 
20194 
20195   if [ -z "${UNZIP+x}" ]; then
20196     # The variable is not set by user, try to locate tool using the code snippet
20197     for ac_prog in unzip
20198 do
20199   # Extract the first word of "$ac_prog", so it can be a program name with args.
20200 set dummy $ac_prog; ac_word=$2
20201 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
20202 $as_echo_n "checking for $ac_word... " >&6; }
20203 if ${ac_cv_path_UNZIP+:} false; then :
20204   $as_echo_n "(cached) " >&6
20205 else
20206   case $UNZIP in
20207   [\\/]* | ?:[\\/]*)
20208   ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
20209   ;;
20210   *)
20211   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
20212 for as_dir in $PATH
20213 do
20214   IFS=$as_save_IFS
20215   test -z "$as_dir" && as_dir=.
20216     for ac_exec_ext in '' $ac_executable_extensions; do
20217   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
20218     ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
20219     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
20220     break 2
20221   fi
20222 done
20223   done
20224 IFS=$as_save_IFS
20225 
20226   ;;
20227 esac
20228 fi
20229 UNZIP=$ac_cv_path_UNZIP
20230 if test -n "$UNZIP"; then
20231   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
20232 $as_echo "$UNZIP" >&6; }
20233 else
20234   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20235 $as_echo "no" >&6; }
20236 fi
20237 
20238 
20239   test -n "$UNZIP" && break
20240 done
20241 
20242   else
20243     # The variable is set, but is it from the command line or the environment?
20244 
20245     # Try to remove the string !UNZIP! from our list.
20246     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNZIP!/}
20247     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
20248       # If it failed, the variable was not from the command line. Ignore it,
20249       # but warn the user (except for BASH, which is always set by the calling BASH).
20250       if test "xUNZIP" != xBASH; then
20251         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNZIP from the environment. Use command line variables instead." >&5
20252 $as_echo "$as_me: WARNING: Ignoring value of UNZIP from the environment. Use command line variables instead." >&2;}
20253       fi
20254       # Try to locate tool using the code snippet
20255       for ac_prog in unzip
20256 do
20257   # Extract the first word of "$ac_prog", so it can be a program name with args.
20258 set dummy $ac_prog; ac_word=$2
20259 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
20260 $as_echo_n "checking for $ac_word... " >&6; }
20261 if ${ac_cv_path_UNZIP+:} false; then :
20262   $as_echo_n "(cached) " >&6
20263 else
20264   case $UNZIP in
20265   [\\/]* | ?:[\\/]*)
20266   ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
20267   ;;
20268   *)
20269   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
20270 for as_dir in $PATH
20271 do
20272   IFS=$as_save_IFS
20273   test -z "$as_dir" && as_dir=.
20274     for ac_exec_ext in '' $ac_executable_extensions; do
20275   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
20276     ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
20277     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
20278     break 2
20279   fi
20280 done
20281   done
20282 IFS=$as_save_IFS
20283 
20284   ;;
20285 esac
20286 fi
20287 UNZIP=$ac_cv_path_UNZIP
20288 if test -n "$UNZIP"; then
20289   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
20290 $as_echo "$UNZIP" >&6; }
20291 else
20292   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20293 $as_echo "no" >&6; }
20294 fi
20295 
20296 
20297   test -n "$UNZIP" && break
20298 done
20299 
20300     else
20301       # If it succeeded, then it was overridden by the user. We will use it
20302       # for the tool.
20303 
20304       # First remove it from the list of overridden variables, so we can test
20305       # for unknown variables in the end.
20306       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
20307 
20308       # Check if we try to supply an empty value
20309       if test "x$UNZIP" = x; then
20310         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool UNZIP= (no value)" >&5
20311 $as_echo "$as_me: Setting user supplied tool UNZIP= (no value)" >&6;}
20312         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNZIP" >&5
20313 $as_echo_n "checking for UNZIP... " >&6; }
20314         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
20315 $as_echo "disabled" >&6; }
20316       else
20317         # Check if the provided tool contains a complete path.
20318         tool_specified="$UNZIP"
20319         tool_basename="${tool_specified##*/}"
20320         if test "x$tool_basename" = "x$tool_specified"; then
20321           # A command without a complete path is provided, search $PATH.
20322           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNZIP=$tool_basename" >&5
20323 $as_echo "$as_me: Will search for user supplied tool UNZIP=$tool_basename" >&6;}
20324           # Extract the first word of "$tool_basename", so it can be a program name with args.
20325 set dummy $tool_basename; ac_word=$2
20326 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
20327 $as_echo_n "checking for $ac_word... " >&6; }
20328 if ${ac_cv_path_UNZIP+:} false; then :
20329   $as_echo_n "(cached) " >&6
20330 else
20331   case $UNZIP in
20332   [\\/]* | ?:[\\/]*)
20333   ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
20334   ;;
20335   *)
20336   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
20337 for as_dir in $PATH
20338 do
20339   IFS=$as_save_IFS
20340   test -z "$as_dir" && as_dir=.
20341     for ac_exec_ext in '' $ac_executable_extensions; do
20342   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
20343     ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
20344     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
20345     break 2
20346   fi
20347 done
20348   done
20349 IFS=$as_save_IFS
20350 
20351   ;;
20352 esac
20353 fi
20354 UNZIP=$ac_cv_path_UNZIP
20355 if test -n "$UNZIP"; then
20356   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
20357 $as_echo "$UNZIP" >&6; }
20358 else
20359   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20360 $as_echo "no" >&6; }
20361 fi
20362 
20363 
20364           if test "x$UNZIP" = x; then
20365             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
20366           fi
20367         else
20368           # Otherwise we believe it is a complete path. Use it as it is.
20369           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNZIP=$tool_specified" >&5
20370 $as_echo "$as_me: Will use user supplied tool UNZIP=$tool_specified" >&6;}
20371           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNZIP" >&5
20372 $as_echo_n "checking for UNZIP... " >&6; }
20373           if test ! -x "$tool_specified"; then
20374             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
20375 $as_echo "not found" >&6; }
20376             as_fn_error $? "User supplied tool UNZIP=$tool_specified does not exist or is not executable" "$LINENO" 5
20377           fi
20378           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
20379 $as_echo "$tool_specified" >&6; }
20380         fi
20381       fi
20382     fi
20383 
20384   fi
20385 
20386 
20387 
20388   if test "x$UNZIP" = x; then
20389     as_fn_error $? "Could not find required tool for UNZIP" "$LINENO" 5
20390   fi
20391 
20392 
20393 
20394 
20395 
20396   # Publish this variable in the help.
20397 
20398 
20399   if [ -z "${ZIP+x}" ]; then
20400     # The variable is not set by user, try to locate tool using the code snippet
20401     for ac_prog in zip
20402 do
20403   # Extract the first word of "$ac_prog", so it can be a program name with args.
20404 set dummy $ac_prog; ac_word=$2
20405 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
20406 $as_echo_n "checking for $ac_word... " >&6; }
20407 if ${ac_cv_path_ZIP+:} false; then :
20408   $as_echo_n "(cached) " >&6
20409 else
20410   case $ZIP in
20411   [\\/]* | ?:[\\/]*)
20412   ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
20413   ;;
20414   *)
20415   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
20416 for as_dir in $PATH
20417 do
20418   IFS=$as_save_IFS
20419   test -z "$as_dir" && as_dir=.
20420     for ac_exec_ext in '' $ac_executable_extensions; do
20421   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
20422     ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
20423     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
20424     break 2
20425   fi
20426 done
20427   done
20428 IFS=$as_save_IFS
20429 
20430   ;;
20431 esac
20432 fi
20433 ZIP=$ac_cv_path_ZIP
20434 if test -n "$ZIP"; then
20435   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
20436 $as_echo "$ZIP" >&6; }
20437 else
20438   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20439 $as_echo "no" >&6; }
20440 fi
20441 
20442 
20443   test -n "$ZIP" && break
20444 done
20445 
20446   else
20447     # The variable is set, but is it from the command line or the environment?
20448 
20449     # Try to remove the string !ZIP! from our list.
20450     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!ZIP!/}
20451     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
20452       # If it failed, the variable was not from the command line. Ignore it,
20453       # but warn the user (except for BASH, which is always set by the calling BASH).
20454       if test "xZIP" != xBASH; then
20455         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ZIP from the environment. Use command line variables instead." >&5
20456 $as_echo "$as_me: WARNING: Ignoring value of ZIP from the environment. Use command line variables instead." >&2;}
20457       fi
20458       # Try to locate tool using the code snippet
20459       for ac_prog in zip
20460 do
20461   # Extract the first word of "$ac_prog", so it can be a program name with args.
20462 set dummy $ac_prog; ac_word=$2
20463 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
20464 $as_echo_n "checking for $ac_word... " >&6; }
20465 if ${ac_cv_path_ZIP+:} false; then :
20466   $as_echo_n "(cached) " >&6
20467 else
20468   case $ZIP in
20469   [\\/]* | ?:[\\/]*)
20470   ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
20471   ;;
20472   *)
20473   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
20474 for as_dir in $PATH
20475 do
20476   IFS=$as_save_IFS
20477   test -z "$as_dir" && as_dir=.
20478     for ac_exec_ext in '' $ac_executable_extensions; do
20479   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
20480     ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
20481     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
20482     break 2
20483   fi
20484 done
20485   done
20486 IFS=$as_save_IFS
20487 
20488   ;;
20489 esac
20490 fi
20491 ZIP=$ac_cv_path_ZIP
20492 if test -n "$ZIP"; then
20493   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
20494 $as_echo "$ZIP" >&6; }
20495 else
20496   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20497 $as_echo "no" >&6; }
20498 fi
20499 
20500 
20501   test -n "$ZIP" && break
20502 done
20503 
20504     else
20505       # If it succeeded, then it was overridden by the user. We will use it
20506       # for the tool.
20507 
20508       # First remove it from the list of overridden variables, so we can test
20509       # for unknown variables in the end.
20510       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
20511 
20512       # Check if we try to supply an empty value
20513       if test "x$ZIP" = x; then
20514         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool ZIP= (no value)" >&5
20515 $as_echo "$as_me: Setting user supplied tool ZIP= (no value)" >&6;}
20516         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ZIP" >&5
20517 $as_echo_n "checking for ZIP... " >&6; }
20518         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
20519 $as_echo "disabled" >&6; }
20520       else
20521         # Check if the provided tool contains a complete path.
20522         tool_specified="$ZIP"
20523         tool_basename="${tool_specified##*/}"
20524         if test "x$tool_basename" = "x$tool_specified"; then
20525           # A command without a complete path is provided, search $PATH.
20526           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ZIP=$tool_basename" >&5
20527 $as_echo "$as_me: Will search for user supplied tool ZIP=$tool_basename" >&6;}
20528           # Extract the first word of "$tool_basename", so it can be a program name with args.
20529 set dummy $tool_basename; ac_word=$2
20530 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
20531 $as_echo_n "checking for $ac_word... " >&6; }
20532 if ${ac_cv_path_ZIP+:} false; then :
20533   $as_echo_n "(cached) " >&6
20534 else
20535   case $ZIP in
20536   [\\/]* | ?:[\\/]*)
20537   ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
20538   ;;
20539   *)
20540   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
20541 for as_dir in $PATH
20542 do
20543   IFS=$as_save_IFS
20544   test -z "$as_dir" && as_dir=.
20545     for ac_exec_ext in '' $ac_executable_extensions; do
20546   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
20547     ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
20548     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
20549     break 2
20550   fi
20551 done
20552   done
20553 IFS=$as_save_IFS
20554 
20555   ;;
20556 esac
20557 fi
20558 ZIP=$ac_cv_path_ZIP
20559 if test -n "$ZIP"; then
20560   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
20561 $as_echo "$ZIP" >&6; }
20562 else
20563   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20564 $as_echo "no" >&6; }
20565 fi
20566 
20567 
20568           if test "x$ZIP" = x; then
20569             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
20570           fi
20571         else
20572           # Otherwise we believe it is a complete path. Use it as it is.
20573           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ZIP=$tool_specified" >&5
20574 $as_echo "$as_me: Will use user supplied tool ZIP=$tool_specified" >&6;}
20575           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ZIP" >&5
20576 $as_echo_n "checking for ZIP... " >&6; }
20577           if test ! -x "$tool_specified"; then
20578             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
20579 $as_echo "not found" >&6; }
20580             as_fn_error $? "User supplied tool ZIP=$tool_specified does not exist or is not executable" "$LINENO" 5
20581           fi
20582           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
20583 $as_echo "$tool_specified" >&6; }
20584         fi
20585       fi
20586     fi
20587 
20588   fi
20589 
20590 
20591 
20592   if test "x$ZIP" = x; then
20593     as_fn_error $? "Could not find required tool for ZIP" "$LINENO" 5
20594   fi
20595 
20596 
20597 
20598   # Non-required basic tools
20599 
20600 
20601 
20602   # Publish this variable in the help.
20603 
20604 
20605   if [ -z "${LDD+x}" ]; then
20606     # The variable is not set by user, try to locate tool using the code snippet
20607     for ac_prog in ldd
20608 do
20609   # Extract the first word of "$ac_prog", so it can be a program name with args.
20610 set dummy $ac_prog; ac_word=$2
20611 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
20612 $as_echo_n "checking for $ac_word... " >&6; }
20613 if ${ac_cv_path_LDD+:} false; then :
20614   $as_echo_n "(cached) " >&6
20615 else
20616   case $LDD in
20617   [\\/]* | ?:[\\/]*)
20618   ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
20619   ;;
20620   *)
20621   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
20622 for as_dir in $PATH
20623 do
20624   IFS=$as_save_IFS
20625   test -z "$as_dir" && as_dir=.
20626     for ac_exec_ext in '' $ac_executable_extensions; do
20627   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
20628     ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
20629     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
20630     break 2
20631   fi
20632 done
20633   done
20634 IFS=$as_save_IFS
20635 
20636   ;;
20637 esac
20638 fi
20639 LDD=$ac_cv_path_LDD
20640 if test -n "$LDD"; then
20641   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
20642 $as_echo "$LDD" >&6; }
20643 else
20644   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20645 $as_echo "no" >&6; }
20646 fi
20647 
20648 
20649   test -n "$LDD" && break
20650 done
20651 
20652   else
20653     # The variable is set, but is it from the command line or the environment?
20654 
20655     # Try to remove the string !LDD! from our list.
20656     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LDD!/}
20657     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
20658       # If it failed, the variable was not from the command line. Ignore it,
20659       # but warn the user (except for BASH, which is always set by the calling BASH).
20660       if test "xLDD" != xBASH; then
20661         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LDD from the environment. Use command line variables instead." >&5
20662 $as_echo "$as_me: WARNING: Ignoring value of LDD from the environment. Use command line variables instead." >&2;}
20663       fi
20664       # Try to locate tool using the code snippet
20665       for ac_prog in ldd
20666 do
20667   # Extract the first word of "$ac_prog", so it can be a program name with args.
20668 set dummy $ac_prog; ac_word=$2
20669 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
20670 $as_echo_n "checking for $ac_word... " >&6; }
20671 if ${ac_cv_path_LDD+:} false; then :
20672   $as_echo_n "(cached) " >&6
20673 else
20674   case $LDD in
20675   [\\/]* | ?:[\\/]*)
20676   ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
20677   ;;
20678   *)
20679   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
20680 for as_dir in $PATH
20681 do
20682   IFS=$as_save_IFS
20683   test -z "$as_dir" && as_dir=.
20684     for ac_exec_ext in '' $ac_executable_extensions; do
20685   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
20686     ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
20687     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
20688     break 2
20689   fi
20690 done
20691   done
20692 IFS=$as_save_IFS
20693 
20694   ;;
20695 esac
20696 fi
20697 LDD=$ac_cv_path_LDD
20698 if test -n "$LDD"; then
20699   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
20700 $as_echo "$LDD" >&6; }
20701 else
20702   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20703 $as_echo "no" >&6; }
20704 fi
20705 
20706 
20707   test -n "$LDD" && break
20708 done
20709 
20710     else
20711       # If it succeeded, then it was overridden by the user. We will use it
20712       # for the tool.
20713 
20714       # First remove it from the list of overridden variables, so we can test
20715       # for unknown variables in the end.
20716       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
20717 
20718       # Check if we try to supply an empty value
20719       if test "x$LDD" = x; then
20720         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool LDD= (no value)" >&5
20721 $as_echo "$as_me: Setting user supplied tool LDD= (no value)" >&6;}
20722         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LDD" >&5
20723 $as_echo_n "checking for LDD... " >&6; }
20724         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
20725 $as_echo "disabled" >&6; }
20726       else
20727         # Check if the provided tool contains a complete path.
20728         tool_specified="$LDD"
20729         tool_basename="${tool_specified##*/}"
20730         if test "x$tool_basename" = "x$tool_specified"; then
20731           # A command without a complete path is provided, search $PATH.
20732           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LDD=$tool_basename" >&5
20733 $as_echo "$as_me: Will search for user supplied tool LDD=$tool_basename" >&6;}
20734           # Extract the first word of "$tool_basename", so it can be a program name with args.
20735 set dummy $tool_basename; ac_word=$2
20736 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
20737 $as_echo_n "checking for $ac_word... " >&6; }
20738 if ${ac_cv_path_LDD+:} false; then :
20739   $as_echo_n "(cached) " >&6
20740 else
20741   case $LDD in
20742   [\\/]* | ?:[\\/]*)
20743   ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
20744   ;;
20745   *)
20746   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
20747 for as_dir in $PATH
20748 do
20749   IFS=$as_save_IFS
20750   test -z "$as_dir" && as_dir=.
20751     for ac_exec_ext in '' $ac_executable_extensions; do
20752   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
20753     ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
20754     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
20755     break 2
20756   fi
20757 done
20758   done
20759 IFS=$as_save_IFS
20760 
20761   ;;
20762 esac
20763 fi
20764 LDD=$ac_cv_path_LDD
20765 if test -n "$LDD"; then
20766   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
20767 $as_echo "$LDD" >&6; }
20768 else
20769   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20770 $as_echo "no" >&6; }
20771 fi
20772 
20773 
20774           if test "x$LDD" = x; then
20775             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
20776           fi
20777         else
20778           # Otherwise we believe it is a complete path. Use it as it is.
20779           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LDD=$tool_specified" >&5
20780 $as_echo "$as_me: Will use user supplied tool LDD=$tool_specified" >&6;}
20781           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LDD" >&5
20782 $as_echo_n "checking for LDD... " >&6; }
20783           if test ! -x "$tool_specified"; then
20784             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
20785 $as_echo "not found" >&6; }
20786             as_fn_error $? "User supplied tool LDD=$tool_specified does not exist or is not executable" "$LINENO" 5
20787           fi
20788           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
20789 $as_echo "$tool_specified" >&6; }
20790         fi
20791       fi
20792     fi
20793 
20794   fi
20795 
20796 
20797   if test "x$LDD" = "x"; then
20798     # List shared lib dependencies is used for
20799     # debug output and checking for forbidden dependencies.
20800     # We can build without it.
20801     LDD="true"
20802   fi
20803 
20804 
20805   # Publish this variable in the help.
20806 
20807 
20808   if [ -z "${OTOOL+x}" ]; then
20809     # The variable is not set by user, try to locate tool using the code snippet
20810     for ac_prog in otool
20811 do
20812   # Extract the first word of "$ac_prog", so it can be a program name with args.
20813 set dummy $ac_prog; ac_word=$2
20814 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
20815 $as_echo_n "checking for $ac_word... " >&6; }
20816 if ${ac_cv_path_OTOOL+:} false; then :
20817   $as_echo_n "(cached) " >&6
20818 else
20819   case $OTOOL in
20820   [\\/]* | ?:[\\/]*)
20821   ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
20822   ;;
20823   *)
20824   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
20825 for as_dir in $PATH
20826 do
20827   IFS=$as_save_IFS
20828   test -z "$as_dir" && as_dir=.
20829     for ac_exec_ext in '' $ac_executable_extensions; do
20830   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
20831     ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
20832     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
20833     break 2
20834   fi
20835 done
20836   done
20837 IFS=$as_save_IFS
20838 
20839   ;;
20840 esac
20841 fi
20842 OTOOL=$ac_cv_path_OTOOL
20843 if test -n "$OTOOL"; then
20844   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
20845 $as_echo "$OTOOL" >&6; }
20846 else
20847   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20848 $as_echo "no" >&6; }
20849 fi
20850 
20851 
20852   test -n "$OTOOL" && break
20853 done
20854 
20855   else
20856     # The variable is set, but is it from the command line or the environment?
20857 
20858     # Try to remove the string !OTOOL! from our list.
20859     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!OTOOL!/}
20860     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
20861       # If it failed, the variable was not from the command line. Ignore it,
20862       # but warn the user (except for BASH, which is always set by the calling BASH).
20863       if test "xOTOOL" != xBASH; then
20864         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of OTOOL from the environment. Use command line variables instead." >&5
20865 $as_echo "$as_me: WARNING: Ignoring value of OTOOL from the environment. Use command line variables instead." >&2;}
20866       fi
20867       # Try to locate tool using the code snippet
20868       for ac_prog in otool
20869 do
20870   # Extract the first word of "$ac_prog", so it can be a program name with args.
20871 set dummy $ac_prog; ac_word=$2
20872 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
20873 $as_echo_n "checking for $ac_word... " >&6; }
20874 if ${ac_cv_path_OTOOL+:} false; then :
20875   $as_echo_n "(cached) " >&6
20876 else
20877   case $OTOOL in
20878   [\\/]* | ?:[\\/]*)
20879   ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
20880   ;;
20881   *)
20882   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
20883 for as_dir in $PATH
20884 do
20885   IFS=$as_save_IFS
20886   test -z "$as_dir" && as_dir=.
20887     for ac_exec_ext in '' $ac_executable_extensions; do
20888   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
20889     ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
20890     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
20891     break 2
20892   fi
20893 done
20894   done
20895 IFS=$as_save_IFS
20896 
20897   ;;
20898 esac
20899 fi
20900 OTOOL=$ac_cv_path_OTOOL
20901 if test -n "$OTOOL"; then
20902   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
20903 $as_echo "$OTOOL" >&6; }
20904 else
20905   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20906 $as_echo "no" >&6; }
20907 fi
20908 
20909 
20910   test -n "$OTOOL" && break
20911 done
20912 
20913     else
20914       # If it succeeded, then it was overridden by the user. We will use it
20915       # for the tool.
20916 
20917       # First remove it from the list of overridden variables, so we can test
20918       # for unknown variables in the end.
20919       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
20920 
20921       # Check if we try to supply an empty value
20922       if test "x$OTOOL" = x; then
20923         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool OTOOL= (no value)" >&5
20924 $as_echo "$as_me: Setting user supplied tool OTOOL= (no value)" >&6;}
20925         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for OTOOL" >&5
20926 $as_echo_n "checking for OTOOL... " >&6; }
20927         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
20928 $as_echo "disabled" >&6; }
20929       else
20930         # Check if the provided tool contains a complete path.
20931         tool_specified="$OTOOL"
20932         tool_basename="${tool_specified##*/}"
20933         if test "x$tool_basename" = "x$tool_specified"; then
20934           # A command without a complete path is provided, search $PATH.
20935           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool OTOOL=$tool_basename" >&5
20936 $as_echo "$as_me: Will search for user supplied tool OTOOL=$tool_basename" >&6;}
20937           # Extract the first word of "$tool_basename", so it can be a program name with args.
20938 set dummy $tool_basename; ac_word=$2
20939 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
20940 $as_echo_n "checking for $ac_word... " >&6; }
20941 if ${ac_cv_path_OTOOL+:} false; then :
20942   $as_echo_n "(cached) " >&6
20943 else
20944   case $OTOOL in
20945   [\\/]* | ?:[\\/]*)
20946   ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
20947   ;;
20948   *)
20949   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
20950 for as_dir in $PATH
20951 do
20952   IFS=$as_save_IFS
20953   test -z "$as_dir" && as_dir=.
20954     for ac_exec_ext in '' $ac_executable_extensions; do
20955   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
20956     ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
20957     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
20958     break 2
20959   fi
20960 done
20961   done
20962 IFS=$as_save_IFS
20963 
20964   ;;
20965 esac
20966 fi
20967 OTOOL=$ac_cv_path_OTOOL
20968 if test -n "$OTOOL"; then
20969   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
20970 $as_echo "$OTOOL" >&6; }
20971 else
20972   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20973 $as_echo "no" >&6; }
20974 fi
20975 
20976 
20977           if test "x$OTOOL" = x; then
20978             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
20979           fi
20980         else
20981           # Otherwise we believe it is a complete path. Use it as it is.
20982           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool OTOOL=$tool_specified" >&5
20983 $as_echo "$as_me: Will use user supplied tool OTOOL=$tool_specified" >&6;}
20984           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for OTOOL" >&5
20985 $as_echo_n "checking for OTOOL... " >&6; }
20986           if test ! -x "$tool_specified"; then
20987             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
20988 $as_echo "not found" >&6; }
20989             as_fn_error $? "User supplied tool OTOOL=$tool_specified does not exist or is not executable" "$LINENO" 5
20990           fi
20991           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
20992 $as_echo "$tool_specified" >&6; }
20993         fi
20994       fi
20995     fi
20996 
20997   fi
20998 
20999 
21000   if test "x$OTOOL" = "x"; then
21001     OTOOL="true"
21002   fi
21003 
21004 
21005   # Publish this variable in the help.
21006 
21007 
21008   if [ -z "${READELF+x}" ]; then
21009     # The variable is not set by user, try to locate tool using the code snippet
21010     for ac_prog in greadelf readelf
21011 do
21012   # Extract the first word of "$ac_prog", so it can be a program name with args.
21013 set dummy $ac_prog; ac_word=$2
21014 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21015 $as_echo_n "checking for $ac_word... " >&6; }
21016 if ${ac_cv_path_READELF+:} false; then :
21017   $as_echo_n "(cached) " >&6
21018 else
21019   case $READELF in
21020   [\\/]* | ?:[\\/]*)
21021   ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
21022   ;;
21023   *)
21024   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21025 for as_dir in $PATH
21026 do
21027   IFS=$as_save_IFS
21028   test -z "$as_dir" && as_dir=.
21029     for ac_exec_ext in '' $ac_executable_extensions; do
21030   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21031     ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
21032     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21033     break 2
21034   fi
21035 done
21036   done
21037 IFS=$as_save_IFS
21038 
21039   ;;
21040 esac
21041 fi
21042 READELF=$ac_cv_path_READELF
21043 if test -n "$READELF"; then
21044   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
21045 $as_echo "$READELF" >&6; }
21046 else
21047   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21048 $as_echo "no" >&6; }
21049 fi
21050 
21051 
21052   test -n "$READELF" && break
21053 done
21054 
21055   else
21056     # The variable is set, but is it from the command line or the environment?
21057 
21058     # Try to remove the string !READELF! from our list.
21059     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!READELF!/}
21060     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
21061       # If it failed, the variable was not from the command line. Ignore it,
21062       # but warn the user (except for BASH, which is always set by the calling BASH).
21063       if test "xREADELF" != xBASH; then
21064         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of READELF from the environment. Use command line variables instead." >&5
21065 $as_echo "$as_me: WARNING: Ignoring value of READELF from the environment. Use command line variables instead." >&2;}
21066       fi
21067       # Try to locate tool using the code snippet
21068       for ac_prog in greadelf readelf
21069 do
21070   # Extract the first word of "$ac_prog", so it can be a program name with args.
21071 set dummy $ac_prog; ac_word=$2
21072 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21073 $as_echo_n "checking for $ac_word... " >&6; }
21074 if ${ac_cv_path_READELF+:} false; then :
21075   $as_echo_n "(cached) " >&6
21076 else
21077   case $READELF in
21078   [\\/]* | ?:[\\/]*)
21079   ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
21080   ;;
21081   *)
21082   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21083 for as_dir in $PATH
21084 do
21085   IFS=$as_save_IFS
21086   test -z "$as_dir" && as_dir=.
21087     for ac_exec_ext in '' $ac_executable_extensions; do
21088   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21089     ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
21090     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21091     break 2
21092   fi
21093 done
21094   done
21095 IFS=$as_save_IFS
21096 
21097   ;;
21098 esac
21099 fi
21100 READELF=$ac_cv_path_READELF
21101 if test -n "$READELF"; then
21102   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
21103 $as_echo "$READELF" >&6; }
21104 else
21105   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21106 $as_echo "no" >&6; }
21107 fi
21108 
21109 
21110   test -n "$READELF" && break
21111 done
21112 
21113     else
21114       # If it succeeded, then it was overridden by the user. We will use it
21115       # for the tool.
21116 
21117       # First remove it from the list of overridden variables, so we can test
21118       # for unknown variables in the end.
21119       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
21120 
21121       # Check if we try to supply an empty value
21122       if test "x$READELF" = x; then
21123         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool READELF= (no value)" >&5
21124 $as_echo "$as_me: Setting user supplied tool READELF= (no value)" >&6;}
21125         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READELF" >&5
21126 $as_echo_n "checking for READELF... " >&6; }
21127         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
21128 $as_echo "disabled" >&6; }
21129       else
21130         # Check if the provided tool contains a complete path.
21131         tool_specified="$READELF"
21132         tool_basename="${tool_specified##*/}"
21133         if test "x$tool_basename" = "x$tool_specified"; then
21134           # A command without a complete path is provided, search $PATH.
21135           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool READELF=$tool_basename" >&5
21136 $as_echo "$as_me: Will search for user supplied tool READELF=$tool_basename" >&6;}
21137           # Extract the first word of "$tool_basename", so it can be a program name with args.
21138 set dummy $tool_basename; ac_word=$2
21139 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21140 $as_echo_n "checking for $ac_word... " >&6; }
21141 if ${ac_cv_path_READELF+:} false; then :
21142   $as_echo_n "(cached) " >&6
21143 else
21144   case $READELF in
21145   [\\/]* | ?:[\\/]*)
21146   ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
21147   ;;
21148   *)
21149   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21150 for as_dir in $PATH
21151 do
21152   IFS=$as_save_IFS
21153   test -z "$as_dir" && as_dir=.
21154     for ac_exec_ext in '' $ac_executable_extensions; do
21155   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21156     ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
21157     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21158     break 2
21159   fi
21160 done
21161   done
21162 IFS=$as_save_IFS
21163 
21164   ;;
21165 esac
21166 fi
21167 READELF=$ac_cv_path_READELF
21168 if test -n "$READELF"; then
21169   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
21170 $as_echo "$READELF" >&6; }
21171 else
21172   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21173 $as_echo "no" >&6; }
21174 fi
21175 
21176 
21177           if test "x$READELF" = x; then
21178             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
21179           fi
21180         else
21181           # Otherwise we believe it is a complete path. Use it as it is.
21182           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool READELF=$tool_specified" >&5
21183 $as_echo "$as_me: Will use user supplied tool READELF=$tool_specified" >&6;}
21184           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READELF" >&5
21185 $as_echo_n "checking for READELF... " >&6; }
21186           if test ! -x "$tool_specified"; then
21187             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
21188 $as_echo "not found" >&6; }
21189             as_fn_error $? "User supplied tool READELF=$tool_specified does not exist or is not executable" "$LINENO" 5
21190           fi
21191           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
21192 $as_echo "$tool_specified" >&6; }
21193         fi
21194       fi
21195     fi
21196 
21197   fi
21198 
21199 
21200 
21201 
21202   # Publish this variable in the help.
21203 
21204 
21205   if [ -z "${HG+x}" ]; then
21206     # The variable is not set by user, try to locate tool using the code snippet
21207     for ac_prog in hg
21208 do
21209   # Extract the first word of "$ac_prog", so it can be a program name with args.
21210 set dummy $ac_prog; ac_word=$2
21211 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21212 $as_echo_n "checking for $ac_word... " >&6; }
21213 if ${ac_cv_path_HG+:} false; then :
21214   $as_echo_n "(cached) " >&6
21215 else
21216   case $HG in
21217   [\\/]* | ?:[\\/]*)
21218   ac_cv_path_HG="$HG" # Let the user override the test with a path.
21219   ;;
21220   *)
21221   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21222 for as_dir in $PATH
21223 do
21224   IFS=$as_save_IFS
21225   test -z "$as_dir" && as_dir=.
21226     for ac_exec_ext in '' $ac_executable_extensions; do
21227   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21228     ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
21229     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21230     break 2
21231   fi
21232 done
21233   done
21234 IFS=$as_save_IFS
21235 
21236   ;;
21237 esac
21238 fi
21239 HG=$ac_cv_path_HG
21240 if test -n "$HG"; then
21241   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
21242 $as_echo "$HG" >&6; }
21243 else
21244   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21245 $as_echo "no" >&6; }
21246 fi
21247 
21248 
21249   test -n "$HG" && break
21250 done
21251 
21252   else
21253     # The variable is set, but is it from the command line or the environment?
21254 
21255     # Try to remove the string !HG! from our list.
21256     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!HG!/}
21257     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
21258       # If it failed, the variable was not from the command line. Ignore it,
21259       # but warn the user (except for BASH, which is always set by the calling BASH).
21260       if test "xHG" != xBASH; then
21261         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of HG from the environment. Use command line variables instead." >&5
21262 $as_echo "$as_me: WARNING: Ignoring value of HG from the environment. Use command line variables instead." >&2;}
21263       fi
21264       # Try to locate tool using the code snippet
21265       for ac_prog in hg
21266 do
21267   # Extract the first word of "$ac_prog", so it can be a program name with args.
21268 set dummy $ac_prog; ac_word=$2
21269 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21270 $as_echo_n "checking for $ac_word... " >&6; }
21271 if ${ac_cv_path_HG+:} false; then :
21272   $as_echo_n "(cached) " >&6
21273 else
21274   case $HG in
21275   [\\/]* | ?:[\\/]*)
21276   ac_cv_path_HG="$HG" # Let the user override the test with a path.
21277   ;;
21278   *)
21279   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21280 for as_dir in $PATH
21281 do
21282   IFS=$as_save_IFS
21283   test -z "$as_dir" && as_dir=.
21284     for ac_exec_ext in '' $ac_executable_extensions; do
21285   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21286     ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
21287     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21288     break 2
21289   fi
21290 done
21291   done
21292 IFS=$as_save_IFS
21293 
21294   ;;
21295 esac
21296 fi
21297 HG=$ac_cv_path_HG
21298 if test -n "$HG"; then
21299   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
21300 $as_echo "$HG" >&6; }
21301 else
21302   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21303 $as_echo "no" >&6; }
21304 fi
21305 
21306 
21307   test -n "$HG" && break
21308 done
21309 
21310     else
21311       # If it succeeded, then it was overridden by the user. We will use it
21312       # for the tool.
21313 
21314       # First remove it from the list of overridden variables, so we can test
21315       # for unknown variables in the end.
21316       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
21317 
21318       # Check if we try to supply an empty value
21319       if test "x$HG" = x; then
21320         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool HG= (no value)" >&5
21321 $as_echo "$as_me: Setting user supplied tool HG= (no value)" >&6;}
21322         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HG" >&5
21323 $as_echo_n "checking for HG... " >&6; }
21324         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
21325 $as_echo "disabled" >&6; }
21326       else
21327         # Check if the provided tool contains a complete path.
21328         tool_specified="$HG"
21329         tool_basename="${tool_specified##*/}"
21330         if test "x$tool_basename" = "x$tool_specified"; then
21331           # A command without a complete path is provided, search $PATH.
21332           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool HG=$tool_basename" >&5
21333 $as_echo "$as_me: Will search for user supplied tool HG=$tool_basename" >&6;}
21334           # Extract the first word of "$tool_basename", so it can be a program name with args.
21335 set dummy $tool_basename; ac_word=$2
21336 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21337 $as_echo_n "checking for $ac_word... " >&6; }
21338 if ${ac_cv_path_HG+:} false; then :
21339   $as_echo_n "(cached) " >&6
21340 else
21341   case $HG in
21342   [\\/]* | ?:[\\/]*)
21343   ac_cv_path_HG="$HG" # Let the user override the test with a path.
21344   ;;
21345   *)
21346   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21347 for as_dir in $PATH
21348 do
21349   IFS=$as_save_IFS
21350   test -z "$as_dir" && as_dir=.
21351     for ac_exec_ext in '' $ac_executable_extensions; do
21352   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21353     ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
21354     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21355     break 2
21356   fi
21357 done
21358   done
21359 IFS=$as_save_IFS
21360 
21361   ;;
21362 esac
21363 fi
21364 HG=$ac_cv_path_HG
21365 if test -n "$HG"; then
21366   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
21367 $as_echo "$HG" >&6; }
21368 else
21369   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21370 $as_echo "no" >&6; }
21371 fi
21372 
21373 
21374           if test "x$HG" = x; then
21375             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
21376           fi
21377         else
21378           # Otherwise we believe it is a complete path. Use it as it is.
21379           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool HG=$tool_specified" >&5
21380 $as_echo "$as_me: Will use user supplied tool HG=$tool_specified" >&6;}
21381           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HG" >&5
21382 $as_echo_n "checking for HG... " >&6; }
21383           if test ! -x "$tool_specified"; then
21384             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
21385 $as_echo "not found" >&6; }
21386             as_fn_error $? "User supplied tool HG=$tool_specified does not exist or is not executable" "$LINENO" 5
21387           fi
21388           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
21389 $as_echo "$tool_specified" >&6; }
21390         fi
21391       fi
21392     fi
21393 
21394   fi
21395 
21396 
21397 
21398 
21399   # Publish this variable in the help.
21400 
21401 
21402   if [ -z "${STAT+x}" ]; then
21403     # The variable is not set by user, try to locate tool using the code snippet
21404     for ac_prog in stat
21405 do
21406   # Extract the first word of "$ac_prog", so it can be a program name with args.
21407 set dummy $ac_prog; ac_word=$2
21408 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21409 $as_echo_n "checking for $ac_word... " >&6; }
21410 if ${ac_cv_path_STAT+:} false; then :
21411   $as_echo_n "(cached) " >&6
21412 else
21413   case $STAT in
21414   [\\/]* | ?:[\\/]*)
21415   ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
21416   ;;
21417   *)
21418   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21419 for as_dir in $PATH
21420 do
21421   IFS=$as_save_IFS
21422   test -z "$as_dir" && as_dir=.
21423     for ac_exec_ext in '' $ac_executable_extensions; do
21424   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21425     ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
21426     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21427     break 2
21428   fi
21429 done
21430   done
21431 IFS=$as_save_IFS
21432 
21433   ;;
21434 esac
21435 fi
21436 STAT=$ac_cv_path_STAT
21437 if test -n "$STAT"; then
21438   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
21439 $as_echo "$STAT" >&6; }
21440 else
21441   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21442 $as_echo "no" >&6; }
21443 fi
21444 
21445 
21446   test -n "$STAT" && break
21447 done
21448 
21449   else
21450     # The variable is set, but is it from the command line or the environment?
21451 
21452     # Try to remove the string !STAT! from our list.
21453     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!STAT!/}
21454     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
21455       # If it failed, the variable was not from the command line. Ignore it,
21456       # but warn the user (except for BASH, which is always set by the calling BASH).
21457       if test "xSTAT" != xBASH; then
21458         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of STAT from the environment. Use command line variables instead." >&5
21459 $as_echo "$as_me: WARNING: Ignoring value of STAT from the environment. Use command line variables instead." >&2;}
21460       fi
21461       # Try to locate tool using the code snippet
21462       for ac_prog in stat
21463 do
21464   # Extract the first word of "$ac_prog", so it can be a program name with args.
21465 set dummy $ac_prog; ac_word=$2
21466 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21467 $as_echo_n "checking for $ac_word... " >&6; }
21468 if ${ac_cv_path_STAT+:} false; then :
21469   $as_echo_n "(cached) " >&6
21470 else
21471   case $STAT in
21472   [\\/]* | ?:[\\/]*)
21473   ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
21474   ;;
21475   *)
21476   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21477 for as_dir in $PATH
21478 do
21479   IFS=$as_save_IFS
21480   test -z "$as_dir" && as_dir=.
21481     for ac_exec_ext in '' $ac_executable_extensions; do
21482   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21483     ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
21484     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21485     break 2
21486   fi
21487 done
21488   done
21489 IFS=$as_save_IFS
21490 
21491   ;;
21492 esac
21493 fi
21494 STAT=$ac_cv_path_STAT
21495 if test -n "$STAT"; then
21496   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
21497 $as_echo "$STAT" >&6; }
21498 else
21499   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21500 $as_echo "no" >&6; }
21501 fi
21502 
21503 
21504   test -n "$STAT" && break
21505 done
21506 
21507     else
21508       # If it succeeded, then it was overridden by the user. We will use it
21509       # for the tool.
21510 
21511       # First remove it from the list of overridden variables, so we can test
21512       # for unknown variables in the end.
21513       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
21514 
21515       # Check if we try to supply an empty value
21516       if test "x$STAT" = x; then
21517         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool STAT= (no value)" >&5
21518 $as_echo "$as_me: Setting user supplied tool STAT= (no value)" >&6;}
21519         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for STAT" >&5
21520 $as_echo_n "checking for STAT... " >&6; }
21521         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
21522 $as_echo "disabled" >&6; }
21523       else
21524         # Check if the provided tool contains a complete path.
21525         tool_specified="$STAT"
21526         tool_basename="${tool_specified##*/}"
21527         if test "x$tool_basename" = "x$tool_specified"; then
21528           # A command without a complete path is provided, search $PATH.
21529           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool STAT=$tool_basename" >&5
21530 $as_echo "$as_me: Will search for user supplied tool STAT=$tool_basename" >&6;}
21531           # Extract the first word of "$tool_basename", so it can be a program name with args.
21532 set dummy $tool_basename; ac_word=$2
21533 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21534 $as_echo_n "checking for $ac_word... " >&6; }
21535 if ${ac_cv_path_STAT+:} false; then :
21536   $as_echo_n "(cached) " >&6
21537 else
21538   case $STAT in
21539   [\\/]* | ?:[\\/]*)
21540   ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
21541   ;;
21542   *)
21543   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21544 for as_dir in $PATH
21545 do
21546   IFS=$as_save_IFS
21547   test -z "$as_dir" && as_dir=.
21548     for ac_exec_ext in '' $ac_executable_extensions; do
21549   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21550     ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
21551     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21552     break 2
21553   fi
21554 done
21555   done
21556 IFS=$as_save_IFS
21557 
21558   ;;
21559 esac
21560 fi
21561 STAT=$ac_cv_path_STAT
21562 if test -n "$STAT"; then
21563   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
21564 $as_echo "$STAT" >&6; }
21565 else
21566   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21567 $as_echo "no" >&6; }
21568 fi
21569 
21570 
21571           if test "x$STAT" = x; then
21572             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
21573           fi
21574         else
21575           # Otherwise we believe it is a complete path. Use it as it is.
21576           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool STAT=$tool_specified" >&5
21577 $as_echo "$as_me: Will use user supplied tool STAT=$tool_specified" >&6;}
21578           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for STAT" >&5
21579 $as_echo_n "checking for STAT... " >&6; }
21580           if test ! -x "$tool_specified"; then
21581             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
21582 $as_echo "not found" >&6; }
21583             as_fn_error $? "User supplied tool STAT=$tool_specified does not exist or is not executable" "$LINENO" 5
21584           fi
21585           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
21586 $as_echo "$tool_specified" >&6; }
21587         fi
21588       fi
21589     fi
21590 
21591   fi
21592 
21593 
21594 
21595 
21596   # Publish this variable in the help.
21597 
21598 
21599   if [ -z "${TIME+x}" ]; then
21600     # The variable is not set by user, try to locate tool using the code snippet
21601     for ac_prog in time
21602 do
21603   # Extract the first word of "$ac_prog", so it can be a program name with args.
21604 set dummy $ac_prog; ac_word=$2
21605 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21606 $as_echo_n "checking for $ac_word... " >&6; }
21607 if ${ac_cv_path_TIME+:} false; then :
21608   $as_echo_n "(cached) " >&6
21609 else
21610   case $TIME in
21611   [\\/]* | ?:[\\/]*)
21612   ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
21613   ;;
21614   *)
21615   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21616 for as_dir in $PATH
21617 do
21618   IFS=$as_save_IFS
21619   test -z "$as_dir" && as_dir=.
21620     for ac_exec_ext in '' $ac_executable_extensions; do
21621   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21622     ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
21623     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21624     break 2
21625   fi
21626 done
21627   done
21628 IFS=$as_save_IFS
21629 
21630   ;;
21631 esac
21632 fi
21633 TIME=$ac_cv_path_TIME
21634 if test -n "$TIME"; then
21635   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
21636 $as_echo "$TIME" >&6; }
21637 else
21638   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21639 $as_echo "no" >&6; }
21640 fi
21641 
21642 
21643   test -n "$TIME" && break
21644 done
21645 
21646   else
21647     # The variable is set, but is it from the command line or the environment?
21648 
21649     # Try to remove the string !TIME! from our list.
21650     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TIME!/}
21651     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
21652       # If it failed, the variable was not from the command line. Ignore it,
21653       # but warn the user (except for BASH, which is always set by the calling BASH).
21654       if test "xTIME" != xBASH; then
21655         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TIME from the environment. Use command line variables instead." >&5
21656 $as_echo "$as_me: WARNING: Ignoring value of TIME from the environment. Use command line variables instead." >&2;}
21657       fi
21658       # Try to locate tool using the code snippet
21659       for ac_prog in time
21660 do
21661   # Extract the first word of "$ac_prog", so it can be a program name with args.
21662 set dummy $ac_prog; ac_word=$2
21663 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21664 $as_echo_n "checking for $ac_word... " >&6; }
21665 if ${ac_cv_path_TIME+:} false; then :
21666   $as_echo_n "(cached) " >&6
21667 else
21668   case $TIME in
21669   [\\/]* | ?:[\\/]*)
21670   ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
21671   ;;
21672   *)
21673   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21674 for as_dir in $PATH
21675 do
21676   IFS=$as_save_IFS
21677   test -z "$as_dir" && as_dir=.
21678     for ac_exec_ext in '' $ac_executable_extensions; do
21679   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21680     ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
21681     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21682     break 2
21683   fi
21684 done
21685   done
21686 IFS=$as_save_IFS
21687 
21688   ;;
21689 esac
21690 fi
21691 TIME=$ac_cv_path_TIME
21692 if test -n "$TIME"; then
21693   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
21694 $as_echo "$TIME" >&6; }
21695 else
21696   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21697 $as_echo "no" >&6; }
21698 fi
21699 
21700 
21701   test -n "$TIME" && break
21702 done
21703 
21704     else
21705       # If it succeeded, then it was overridden by the user. We will use it
21706       # for the tool.
21707 
21708       # First remove it from the list of overridden variables, so we can test
21709       # for unknown variables in the end.
21710       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
21711 
21712       # Check if we try to supply an empty value
21713       if test "x$TIME" = x; then
21714         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool TIME= (no value)" >&5
21715 $as_echo "$as_me: Setting user supplied tool TIME= (no value)" >&6;}
21716         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TIME" >&5
21717 $as_echo_n "checking for TIME... " >&6; }
21718         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
21719 $as_echo "disabled" >&6; }
21720       else
21721         # Check if the provided tool contains a complete path.
21722         tool_specified="$TIME"
21723         tool_basename="${tool_specified##*/}"
21724         if test "x$tool_basename" = "x$tool_specified"; then
21725           # A command without a complete path is provided, search $PATH.
21726           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TIME=$tool_basename" >&5
21727 $as_echo "$as_me: Will search for user supplied tool TIME=$tool_basename" >&6;}
21728           # Extract the first word of "$tool_basename", so it can be a program name with args.
21729 set dummy $tool_basename; ac_word=$2
21730 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21731 $as_echo_n "checking for $ac_word... " >&6; }
21732 if ${ac_cv_path_TIME+:} false; then :
21733   $as_echo_n "(cached) " >&6
21734 else
21735   case $TIME in
21736   [\\/]* | ?:[\\/]*)
21737   ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
21738   ;;
21739   *)
21740   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21741 for as_dir in $PATH
21742 do
21743   IFS=$as_save_IFS
21744   test -z "$as_dir" && as_dir=.
21745     for ac_exec_ext in '' $ac_executable_extensions; do
21746   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21747     ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
21748     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21749     break 2
21750   fi
21751 done
21752   done
21753 IFS=$as_save_IFS
21754 
21755   ;;
21756 esac
21757 fi
21758 TIME=$ac_cv_path_TIME
21759 if test -n "$TIME"; then
21760   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
21761 $as_echo "$TIME" >&6; }
21762 else
21763   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21764 $as_echo "no" >&6; }
21765 fi
21766 
21767 
21768           if test "x$TIME" = x; then
21769             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
21770           fi
21771         else
21772           # Otherwise we believe it is a complete path. Use it as it is.
21773           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TIME=$tool_specified" >&5
21774 $as_echo "$as_me: Will use user supplied tool TIME=$tool_specified" >&6;}
21775           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TIME" >&5
21776 $as_echo_n "checking for TIME... " >&6; }
21777           if test ! -x "$tool_specified"; then
21778             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
21779 $as_echo "not found" >&6; }
21780             as_fn_error $? "User supplied tool TIME=$tool_specified does not exist or is not executable" "$LINENO" 5
21781           fi
21782           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
21783 $as_echo "$tool_specified" >&6; }
21784         fi
21785       fi
21786     fi
21787 
21788   fi
21789 
21790 
21791 
21792 
21793   # Publish this variable in the help.
21794 
21795 
21796   if [ -z "${PATCH+x}" ]; then
21797     # The variable is not set by user, try to locate tool using the code snippet
21798     for ac_prog in gpatch patch
21799 do
21800   # Extract the first word of "$ac_prog", so it can be a program name with args.
21801 set dummy $ac_prog; ac_word=$2
21802 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21803 $as_echo_n "checking for $ac_word... " >&6; }
21804 if ${ac_cv_path_PATCH+:} false; then :
21805   $as_echo_n "(cached) " >&6
21806 else
21807   case $PATCH in
21808   [\\/]* | ?:[\\/]*)
21809   ac_cv_path_PATCH="$PATCH" # Let the user override the test with a path.
21810   ;;
21811   *)
21812   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21813 for as_dir in $PATH
21814 do
21815   IFS=$as_save_IFS
21816   test -z "$as_dir" && as_dir=.
21817     for ac_exec_ext in '' $ac_executable_extensions; do
21818   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21819     ac_cv_path_PATCH="$as_dir/$ac_word$ac_exec_ext"
21820     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21821     break 2
21822   fi
21823 done
21824   done
21825 IFS=$as_save_IFS
21826 
21827   ;;
21828 esac
21829 fi
21830 PATCH=$ac_cv_path_PATCH
21831 if test -n "$PATCH"; then
21832   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PATCH" >&5
21833 $as_echo "$PATCH" >&6; }
21834 else
21835   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21836 $as_echo "no" >&6; }
21837 fi
21838 
21839 
21840   test -n "$PATCH" && break
21841 done
21842 
21843   else
21844     # The variable is set, but is it from the command line or the environment?
21845 
21846     # Try to remove the string !PATCH! from our list.
21847     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!PATCH!/}
21848     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
21849       # If it failed, the variable was not from the command line. Ignore it,
21850       # but warn the user (except for BASH, which is always set by the calling BASH).
21851       if test "xPATCH" != xBASH; then
21852         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of PATCH from the environment. Use command line variables instead." >&5
21853 $as_echo "$as_me: WARNING: Ignoring value of PATCH from the environment. Use command line variables instead." >&2;}
21854       fi
21855       # Try to locate tool using the code snippet
21856       for ac_prog in gpatch patch
21857 do
21858   # Extract the first word of "$ac_prog", so it can be a program name with args.
21859 set dummy $ac_prog; ac_word=$2
21860 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21861 $as_echo_n "checking for $ac_word... " >&6; }
21862 if ${ac_cv_path_PATCH+:} false; then :
21863   $as_echo_n "(cached) " >&6
21864 else
21865   case $PATCH in
21866   [\\/]* | ?:[\\/]*)
21867   ac_cv_path_PATCH="$PATCH" # Let the user override the test with a path.
21868   ;;
21869   *)
21870   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21871 for as_dir in $PATH
21872 do
21873   IFS=$as_save_IFS
21874   test -z "$as_dir" && as_dir=.
21875     for ac_exec_ext in '' $ac_executable_extensions; do
21876   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21877     ac_cv_path_PATCH="$as_dir/$ac_word$ac_exec_ext"
21878     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21879     break 2
21880   fi
21881 done
21882   done
21883 IFS=$as_save_IFS
21884 
21885   ;;
21886 esac
21887 fi
21888 PATCH=$ac_cv_path_PATCH
21889 if test -n "$PATCH"; then
21890   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PATCH" >&5
21891 $as_echo "$PATCH" >&6; }
21892 else
21893   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21894 $as_echo "no" >&6; }
21895 fi
21896 
21897 
21898   test -n "$PATCH" && break
21899 done
21900 
21901     else
21902       # If it succeeded, then it was overridden by the user. We will use it
21903       # for the tool.
21904 
21905       # First remove it from the list of overridden variables, so we can test
21906       # for unknown variables in the end.
21907       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
21908 
21909       # Check if we try to supply an empty value
21910       if test "x$PATCH" = x; then
21911         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool PATCH= (no value)" >&5
21912 $as_echo "$as_me: Setting user supplied tool PATCH= (no value)" >&6;}
21913         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PATCH" >&5
21914 $as_echo_n "checking for PATCH... " >&6; }
21915         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
21916 $as_echo "disabled" >&6; }
21917       else
21918         # Check if the provided tool contains a complete path.
21919         tool_specified="$PATCH"
21920         tool_basename="${tool_specified##*/}"
21921         if test "x$tool_basename" = "x$tool_specified"; then
21922           # A command without a complete path is provided, search $PATH.
21923           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool PATCH=$tool_basename" >&5
21924 $as_echo "$as_me: Will search for user supplied tool PATCH=$tool_basename" >&6;}
21925           # Extract the first word of "$tool_basename", so it can be a program name with args.
21926 set dummy $tool_basename; ac_word=$2
21927 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21928 $as_echo_n "checking for $ac_word... " >&6; }
21929 if ${ac_cv_path_PATCH+:} false; then :
21930   $as_echo_n "(cached) " >&6
21931 else
21932   case $PATCH in
21933   [\\/]* | ?:[\\/]*)
21934   ac_cv_path_PATCH="$PATCH" # Let the user override the test with a path.
21935   ;;
21936   *)
21937   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21938 for as_dir in $PATH
21939 do
21940   IFS=$as_save_IFS
21941   test -z "$as_dir" && as_dir=.
21942     for ac_exec_ext in '' $ac_executable_extensions; do
21943   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21944     ac_cv_path_PATCH="$as_dir/$ac_word$ac_exec_ext"
21945     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21946     break 2
21947   fi
21948 done
21949   done
21950 IFS=$as_save_IFS
21951 
21952   ;;
21953 esac
21954 fi
21955 PATCH=$ac_cv_path_PATCH
21956 if test -n "$PATCH"; then
21957   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PATCH" >&5
21958 $as_echo "$PATCH" >&6; }
21959 else
21960   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21961 $as_echo "no" >&6; }
21962 fi
21963 
21964 
21965           if test "x$PATCH" = x; then
21966             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
21967           fi
21968         else
21969           # Otherwise we believe it is a complete path. Use it as it is.
21970           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool PATCH=$tool_specified" >&5
21971 $as_echo "$as_me: Will use user supplied tool PATCH=$tool_specified" >&6;}
21972           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PATCH" >&5
21973 $as_echo_n "checking for PATCH... " >&6; }
21974           if test ! -x "$tool_specified"; then
21975             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
21976 $as_echo "not found" >&6; }
21977             as_fn_error $? "User supplied tool PATCH=$tool_specified does not exist or is not executable" "$LINENO" 5
21978           fi
21979           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
21980 $as_echo "$tool_specified" >&6; }
21981         fi
21982       fi
21983     fi
21984 
21985   fi
21986 
21987 
21988   # Check if it's GNU time
21989   IS_GNU_TIME=`$TIME --version 2>&1 | $GREP 'GNU time'`
21990   if test "x$IS_GNU_TIME" != x; then
21991     IS_GNU_TIME=yes
21992   else
21993     IS_GNU_TIME=no
21994   fi
21995 
21996 
21997   if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
21998 
21999 
22000 
22001   # Publish this variable in the help.
22002 
22003 
22004   if [ -z "${DSYMUTIL+x}" ]; then
22005     # The variable is not set by user, try to locate tool using the code snippet
22006     for ac_prog in dsymutil
22007 do
22008   # Extract the first word of "$ac_prog", so it can be a program name with args.
22009 set dummy $ac_prog; ac_word=$2
22010 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22011 $as_echo_n "checking for $ac_word... " >&6; }
22012 if ${ac_cv_path_DSYMUTIL+:} false; then :
22013   $as_echo_n "(cached) " >&6
22014 else
22015   case $DSYMUTIL in
22016   [\\/]* | ?:[\\/]*)
22017   ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
22018   ;;
22019   *)
22020   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22021 for as_dir in $PATH
22022 do
22023   IFS=$as_save_IFS
22024   test -z "$as_dir" && as_dir=.
22025     for ac_exec_ext in '' $ac_executable_extensions; do
22026   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22027     ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
22028     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22029     break 2
22030   fi
22031 done
22032   done
22033 IFS=$as_save_IFS
22034 
22035   ;;
22036 esac
22037 fi
22038 DSYMUTIL=$ac_cv_path_DSYMUTIL
22039 if test -n "$DSYMUTIL"; then
22040   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
22041 $as_echo "$DSYMUTIL" >&6; }
22042 else
22043   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22044 $as_echo "no" >&6; }
22045 fi
22046 
22047 
22048   test -n "$DSYMUTIL" && break
22049 done
22050 
22051   else
22052     # The variable is set, but is it from the command line or the environment?
22053 
22054     # Try to remove the string !DSYMUTIL! from our list.
22055     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DSYMUTIL!/}
22056     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
22057       # If it failed, the variable was not from the command line. Ignore it,
22058       # but warn the user (except for BASH, which is always set by the calling BASH).
22059       if test "xDSYMUTIL" != xBASH; then
22060         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DSYMUTIL from the environment. Use command line variables instead." >&5
22061 $as_echo "$as_me: WARNING: Ignoring value of DSYMUTIL from the environment. Use command line variables instead." >&2;}
22062       fi
22063       # Try to locate tool using the code snippet
22064       for ac_prog in dsymutil
22065 do
22066   # Extract the first word of "$ac_prog", so it can be a program name with args.
22067 set dummy $ac_prog; ac_word=$2
22068 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22069 $as_echo_n "checking for $ac_word... " >&6; }
22070 if ${ac_cv_path_DSYMUTIL+:} false; then :
22071   $as_echo_n "(cached) " >&6
22072 else
22073   case $DSYMUTIL in
22074   [\\/]* | ?:[\\/]*)
22075   ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
22076   ;;
22077   *)
22078   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22079 for as_dir in $PATH
22080 do
22081   IFS=$as_save_IFS
22082   test -z "$as_dir" && as_dir=.
22083     for ac_exec_ext in '' $ac_executable_extensions; do
22084   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22085     ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
22086     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22087     break 2
22088   fi
22089 done
22090   done
22091 IFS=$as_save_IFS
22092 
22093   ;;
22094 esac
22095 fi
22096 DSYMUTIL=$ac_cv_path_DSYMUTIL
22097 if test -n "$DSYMUTIL"; then
22098   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
22099 $as_echo "$DSYMUTIL" >&6; }
22100 else
22101   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22102 $as_echo "no" >&6; }
22103 fi
22104 
22105 
22106   test -n "$DSYMUTIL" && break
22107 done
22108 
22109     else
22110       # If it succeeded, then it was overridden by the user. We will use it
22111       # for the tool.
22112 
22113       # First remove it from the list of overridden variables, so we can test
22114       # for unknown variables in the end.
22115       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
22116 
22117       # Check if we try to supply an empty value
22118       if test "x$DSYMUTIL" = x; then
22119         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool DSYMUTIL= (no value)" >&5
22120 $as_echo "$as_me: Setting user supplied tool DSYMUTIL= (no value)" >&6;}
22121         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DSYMUTIL" >&5
22122 $as_echo_n "checking for DSYMUTIL... " >&6; }
22123         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
22124 $as_echo "disabled" >&6; }
22125       else
22126         # Check if the provided tool contains a complete path.
22127         tool_specified="$DSYMUTIL"
22128         tool_basename="${tool_specified##*/}"
22129         if test "x$tool_basename" = "x$tool_specified"; then
22130           # A command without a complete path is provided, search $PATH.
22131           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DSYMUTIL=$tool_basename" >&5
22132 $as_echo "$as_me: Will search for user supplied tool DSYMUTIL=$tool_basename" >&6;}
22133           # Extract the first word of "$tool_basename", so it can be a program name with args.
22134 set dummy $tool_basename; ac_word=$2
22135 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22136 $as_echo_n "checking for $ac_word... " >&6; }
22137 if ${ac_cv_path_DSYMUTIL+:} false; then :
22138   $as_echo_n "(cached) " >&6
22139 else
22140   case $DSYMUTIL in
22141   [\\/]* | ?:[\\/]*)
22142   ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
22143   ;;
22144   *)
22145   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22146 for as_dir in $PATH
22147 do
22148   IFS=$as_save_IFS
22149   test -z "$as_dir" && as_dir=.
22150     for ac_exec_ext in '' $ac_executable_extensions; do
22151   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22152     ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
22153     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22154     break 2
22155   fi
22156 done
22157   done
22158 IFS=$as_save_IFS
22159 
22160   ;;
22161 esac
22162 fi
22163 DSYMUTIL=$ac_cv_path_DSYMUTIL
22164 if test -n "$DSYMUTIL"; then
22165   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
22166 $as_echo "$DSYMUTIL" >&6; }
22167 else
22168   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22169 $as_echo "no" >&6; }
22170 fi
22171 
22172 
22173           if test "x$DSYMUTIL" = x; then
22174             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
22175           fi
22176         else
22177           # Otherwise we believe it is a complete path. Use it as it is.
22178           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DSYMUTIL=$tool_specified" >&5
22179 $as_echo "$as_me: Will use user supplied tool DSYMUTIL=$tool_specified" >&6;}
22180           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DSYMUTIL" >&5
22181 $as_echo_n "checking for DSYMUTIL... " >&6; }
22182           if test ! -x "$tool_specified"; then
22183             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
22184 $as_echo "not found" >&6; }
22185             as_fn_error $? "User supplied tool DSYMUTIL=$tool_specified does not exist or is not executable" "$LINENO" 5
22186           fi
22187           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
22188 $as_echo "$tool_specified" >&6; }
22189         fi
22190       fi
22191     fi
22192 
22193   fi
22194 
22195 
22196 
22197   if test "x$DSYMUTIL" = x; then
22198     as_fn_error $? "Could not find required tool for DSYMUTIL" "$LINENO" 5
22199   fi
22200 
22201 
22202 
22203 
22204 
22205   # Publish this variable in the help.
22206 
22207 
22208   if [ -z "${XATTR+x}" ]; then
22209     # The variable is not set by user, try to locate tool using the code snippet
22210     for ac_prog in xattr
22211 do
22212   # Extract the first word of "$ac_prog", so it can be a program name with args.
22213 set dummy $ac_prog; ac_word=$2
22214 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22215 $as_echo_n "checking for $ac_word... " >&6; }
22216 if ${ac_cv_path_XATTR+:} false; then :
22217   $as_echo_n "(cached) " >&6
22218 else
22219   case $XATTR in
22220   [\\/]* | ?:[\\/]*)
22221   ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
22222   ;;
22223   *)
22224   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22225 for as_dir in $PATH
22226 do
22227   IFS=$as_save_IFS
22228   test -z "$as_dir" && as_dir=.
22229     for ac_exec_ext in '' $ac_executable_extensions; do
22230   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22231     ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
22232     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22233     break 2
22234   fi
22235 done
22236   done
22237 IFS=$as_save_IFS
22238 
22239   ;;
22240 esac
22241 fi
22242 XATTR=$ac_cv_path_XATTR
22243 if test -n "$XATTR"; then
22244   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
22245 $as_echo "$XATTR" >&6; }
22246 else
22247   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22248 $as_echo "no" >&6; }
22249 fi
22250 
22251 
22252   test -n "$XATTR" && break
22253 done
22254 
22255   else
22256     # The variable is set, but is it from the command line or the environment?
22257 
22258     # Try to remove the string !XATTR! from our list.
22259     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!XATTR!/}
22260     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
22261       # If it failed, the variable was not from the command line. Ignore it,
22262       # but warn the user (except for BASH, which is always set by the calling BASH).
22263       if test "xXATTR" != xBASH; then
22264         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of XATTR from the environment. Use command line variables instead." >&5
22265 $as_echo "$as_me: WARNING: Ignoring value of XATTR from the environment. Use command line variables instead." >&2;}
22266       fi
22267       # Try to locate tool using the code snippet
22268       for ac_prog in xattr
22269 do
22270   # Extract the first word of "$ac_prog", so it can be a program name with args.
22271 set dummy $ac_prog; ac_word=$2
22272 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22273 $as_echo_n "checking for $ac_word... " >&6; }
22274 if ${ac_cv_path_XATTR+:} false; then :
22275   $as_echo_n "(cached) " >&6
22276 else
22277   case $XATTR in
22278   [\\/]* | ?:[\\/]*)
22279   ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
22280   ;;
22281   *)
22282   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22283 for as_dir in $PATH
22284 do
22285   IFS=$as_save_IFS
22286   test -z "$as_dir" && as_dir=.
22287     for ac_exec_ext in '' $ac_executable_extensions; do
22288   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22289     ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
22290     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22291     break 2
22292   fi
22293 done
22294   done
22295 IFS=$as_save_IFS
22296 
22297   ;;
22298 esac
22299 fi
22300 XATTR=$ac_cv_path_XATTR
22301 if test -n "$XATTR"; then
22302   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
22303 $as_echo "$XATTR" >&6; }
22304 else
22305   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22306 $as_echo "no" >&6; }
22307 fi
22308 
22309 
22310   test -n "$XATTR" && break
22311 done
22312 
22313     else
22314       # If it succeeded, then it was overridden by the user. We will use it
22315       # for the tool.
22316 
22317       # First remove it from the list of overridden variables, so we can test
22318       # for unknown variables in the end.
22319       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
22320 
22321       # Check if we try to supply an empty value
22322       if test "x$XATTR" = x; then
22323         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool XATTR= (no value)" >&5
22324 $as_echo "$as_me: Setting user supplied tool XATTR= (no value)" >&6;}
22325         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XATTR" >&5
22326 $as_echo_n "checking for XATTR... " >&6; }
22327         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
22328 $as_echo "disabled" >&6; }
22329       else
22330         # Check if the provided tool contains a complete path.
22331         tool_specified="$XATTR"
22332         tool_basename="${tool_specified##*/}"
22333         if test "x$tool_basename" = "x$tool_specified"; then
22334           # A command without a complete path is provided, search $PATH.
22335           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool XATTR=$tool_basename" >&5
22336 $as_echo "$as_me: Will search for user supplied tool XATTR=$tool_basename" >&6;}
22337           # Extract the first word of "$tool_basename", so it can be a program name with args.
22338 set dummy $tool_basename; ac_word=$2
22339 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22340 $as_echo_n "checking for $ac_word... " >&6; }
22341 if ${ac_cv_path_XATTR+:} false; then :
22342   $as_echo_n "(cached) " >&6
22343 else
22344   case $XATTR in
22345   [\\/]* | ?:[\\/]*)
22346   ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
22347   ;;
22348   *)
22349   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22350 for as_dir in $PATH
22351 do
22352   IFS=$as_save_IFS
22353   test -z "$as_dir" && as_dir=.
22354     for ac_exec_ext in '' $ac_executable_extensions; do
22355   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22356     ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
22357     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22358     break 2
22359   fi
22360 done
22361   done
22362 IFS=$as_save_IFS
22363 
22364   ;;
22365 esac
22366 fi
22367 XATTR=$ac_cv_path_XATTR
22368 if test -n "$XATTR"; then
22369   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
22370 $as_echo "$XATTR" >&6; }
22371 else
22372   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22373 $as_echo "no" >&6; }
22374 fi
22375 
22376 
22377           if test "x$XATTR" = x; then
22378             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
22379           fi
22380         else
22381           # Otherwise we believe it is a complete path. Use it as it is.
22382           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool XATTR=$tool_specified" >&5
22383 $as_echo "$as_me: Will use user supplied tool XATTR=$tool_specified" >&6;}
22384           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XATTR" >&5
22385 $as_echo_n "checking for XATTR... " >&6; }
22386           if test ! -x "$tool_specified"; then
22387             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
22388 $as_echo "not found" >&6; }
22389             as_fn_error $? "User supplied tool XATTR=$tool_specified does not exist or is not executable" "$LINENO" 5
22390           fi
22391           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
22392 $as_echo "$tool_specified" >&6; }
22393         fi
22394       fi
22395     fi
22396 
22397   fi
22398 
22399 
22400 
22401   if test "x$XATTR" = x; then
22402     as_fn_error $? "Could not find required tool for XATTR" "$LINENO" 5
22403   fi
22404 
22405 
22406 
22407 
22408   # Publish this variable in the help.
22409 
22410 
22411   if [ -z "${CODESIGN+x}" ]; then
22412     # The variable is not set by user, try to locate tool using the code snippet
22413     for ac_prog in codesign
22414 do
22415   # Extract the first word of "$ac_prog", so it can be a program name with args.
22416 set dummy $ac_prog; ac_word=$2
22417 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22418 $as_echo_n "checking for $ac_word... " >&6; }
22419 if ${ac_cv_path_CODESIGN+:} false; then :
22420   $as_echo_n "(cached) " >&6
22421 else
22422   case $CODESIGN in
22423   [\\/]* | ?:[\\/]*)
22424   ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
22425   ;;
22426   *)
22427   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22428 for as_dir in $PATH
22429 do
22430   IFS=$as_save_IFS
22431   test -z "$as_dir" && as_dir=.
22432     for ac_exec_ext in '' $ac_executable_extensions; do
22433   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22434     ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
22435     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22436     break 2
22437   fi
22438 done
22439   done
22440 IFS=$as_save_IFS
22441 
22442   ;;
22443 esac
22444 fi
22445 CODESIGN=$ac_cv_path_CODESIGN
22446 if test -n "$CODESIGN"; then
22447   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
22448 $as_echo "$CODESIGN" >&6; }
22449 else
22450   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22451 $as_echo "no" >&6; }
22452 fi
22453 
22454 
22455   test -n "$CODESIGN" && break
22456 done
22457 
22458   else
22459     # The variable is set, but is it from the command line or the environment?
22460 
22461     # Try to remove the string !CODESIGN! from our list.
22462     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CODESIGN!/}
22463     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
22464       # If it failed, the variable was not from the command line. Ignore it,
22465       # but warn the user (except for BASH, which is always set by the calling BASH).
22466       if test "xCODESIGN" != xBASH; then
22467         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CODESIGN from the environment. Use command line variables instead." >&5
22468 $as_echo "$as_me: WARNING: Ignoring value of CODESIGN from the environment. Use command line variables instead." >&2;}
22469       fi
22470       # Try to locate tool using the code snippet
22471       for ac_prog in codesign
22472 do
22473   # Extract the first word of "$ac_prog", so it can be a program name with args.
22474 set dummy $ac_prog; ac_word=$2
22475 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22476 $as_echo_n "checking for $ac_word... " >&6; }
22477 if ${ac_cv_path_CODESIGN+:} false; then :
22478   $as_echo_n "(cached) " >&6
22479 else
22480   case $CODESIGN in
22481   [\\/]* | ?:[\\/]*)
22482   ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
22483   ;;
22484   *)
22485   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22486 for as_dir in $PATH
22487 do
22488   IFS=$as_save_IFS
22489   test -z "$as_dir" && as_dir=.
22490     for ac_exec_ext in '' $ac_executable_extensions; do
22491   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22492     ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
22493     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22494     break 2
22495   fi
22496 done
22497   done
22498 IFS=$as_save_IFS
22499 
22500   ;;
22501 esac
22502 fi
22503 CODESIGN=$ac_cv_path_CODESIGN
22504 if test -n "$CODESIGN"; then
22505   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
22506 $as_echo "$CODESIGN" >&6; }
22507 else
22508   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22509 $as_echo "no" >&6; }
22510 fi
22511 
22512 
22513   test -n "$CODESIGN" && break
22514 done
22515 
22516     else
22517       # If it succeeded, then it was overridden by the user. We will use it
22518       # for the tool.
22519 
22520       # First remove it from the list of overridden variables, so we can test
22521       # for unknown variables in the end.
22522       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
22523 
22524       # Check if we try to supply an empty value
22525       if test "x$CODESIGN" = x; then
22526         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CODESIGN= (no value)" >&5
22527 $as_echo "$as_me: Setting user supplied tool CODESIGN= (no value)" >&6;}
22528         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CODESIGN" >&5
22529 $as_echo_n "checking for CODESIGN... " >&6; }
22530         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
22531 $as_echo "disabled" >&6; }
22532       else
22533         # Check if the provided tool contains a complete path.
22534         tool_specified="$CODESIGN"
22535         tool_basename="${tool_specified##*/}"
22536         if test "x$tool_basename" = "x$tool_specified"; then
22537           # A command without a complete path is provided, search $PATH.
22538           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CODESIGN=$tool_basename" >&5
22539 $as_echo "$as_me: Will search for user supplied tool CODESIGN=$tool_basename" >&6;}
22540           # Extract the first word of "$tool_basename", so it can be a program name with args.
22541 set dummy $tool_basename; ac_word=$2
22542 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22543 $as_echo_n "checking for $ac_word... " >&6; }
22544 if ${ac_cv_path_CODESIGN+:} false; then :
22545   $as_echo_n "(cached) " >&6
22546 else
22547   case $CODESIGN in
22548   [\\/]* | ?:[\\/]*)
22549   ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
22550   ;;
22551   *)
22552   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22553 for as_dir in $PATH
22554 do
22555   IFS=$as_save_IFS
22556   test -z "$as_dir" && as_dir=.
22557     for ac_exec_ext in '' $ac_executable_extensions; do
22558   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22559     ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
22560     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22561     break 2
22562   fi
22563 done
22564   done
22565 IFS=$as_save_IFS
22566 
22567   ;;
22568 esac
22569 fi
22570 CODESIGN=$ac_cv_path_CODESIGN
22571 if test -n "$CODESIGN"; then
22572   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
22573 $as_echo "$CODESIGN" >&6; }
22574 else
22575   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22576 $as_echo "no" >&6; }
22577 fi
22578 
22579 
22580           if test "x$CODESIGN" = x; then
22581             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
22582           fi
22583         else
22584           # Otherwise we believe it is a complete path. Use it as it is.
22585           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CODESIGN=$tool_specified" >&5
22586 $as_echo "$as_me: Will use user supplied tool CODESIGN=$tool_specified" >&6;}
22587           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CODESIGN" >&5
22588 $as_echo_n "checking for CODESIGN... " >&6; }
22589           if test ! -x "$tool_specified"; then
22590             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
22591 $as_echo "not found" >&6; }
22592             as_fn_error $? "User supplied tool CODESIGN=$tool_specified does not exist or is not executable" "$LINENO" 5
22593           fi
22594           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
22595 $as_echo "$tool_specified" >&6; }
22596         fi
22597       fi
22598     fi
22599 
22600   fi
22601 
22602 
22603     if test "x$CODESIGN" != "x"; then
22604       # Verify that the openjdk_codesign certificate is present
22605       { $as_echo "$as_me:${as_lineno-$LINENO}: checking if openjdk_codesign certificate is present" >&5
22606 $as_echo_n "checking if openjdk_codesign certificate is present... " >&6; }
22607       rm -f codesign-testfile
22608       touch codesign-testfile
22609       codesign -s openjdk_codesign codesign-testfile 2>&5 >&5 || CODESIGN=
22610       rm -f codesign-testfile
22611       if test "x$CODESIGN" = x; then
22612         { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22613 $as_echo "no" >&6; }
22614       else
22615         { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
22616 $as_echo "yes" >&6; }
22617       fi
22618     fi
22619 
22620 
22621 
22622   # Publish this variable in the help.
22623 
22624 
22625   if [ -z "${SETFILE+x}" ]; then
22626     # The variable is not set by user, try to locate tool using the code snippet
22627     for ac_prog in SetFile
22628 do
22629   # Extract the first word of "$ac_prog", so it can be a program name with args.
22630 set dummy $ac_prog; ac_word=$2
22631 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22632 $as_echo_n "checking for $ac_word... " >&6; }
22633 if ${ac_cv_path_SETFILE+:} false; then :
22634   $as_echo_n "(cached) " >&6
22635 else
22636   case $SETFILE in
22637   [\\/]* | ?:[\\/]*)
22638   ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
22639   ;;
22640   *)
22641   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22642 for as_dir in $PATH
22643 do
22644   IFS=$as_save_IFS
22645   test -z "$as_dir" && as_dir=.
22646     for ac_exec_ext in '' $ac_executable_extensions; do
22647   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22648     ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
22649     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22650     break 2
22651   fi
22652 done
22653   done
22654 IFS=$as_save_IFS
22655 
22656   ;;
22657 esac
22658 fi
22659 SETFILE=$ac_cv_path_SETFILE
22660 if test -n "$SETFILE"; then
22661   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
22662 $as_echo "$SETFILE" >&6; }
22663 else
22664   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22665 $as_echo "no" >&6; }
22666 fi
22667 
22668 
22669   test -n "$SETFILE" && break
22670 done
22671 
22672   else
22673     # The variable is set, but is it from the command line or the environment?
22674 
22675     # Try to remove the string !SETFILE! from our list.
22676     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SETFILE!/}
22677     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
22678       # If it failed, the variable was not from the command line. Ignore it,
22679       # but warn the user (except for BASH, which is always set by the calling BASH).
22680       if test "xSETFILE" != xBASH; then
22681         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SETFILE from the environment. Use command line variables instead." >&5
22682 $as_echo "$as_me: WARNING: Ignoring value of SETFILE from the environment. Use command line variables instead." >&2;}
22683       fi
22684       # Try to locate tool using the code snippet
22685       for ac_prog in SetFile
22686 do
22687   # Extract the first word of "$ac_prog", so it can be a program name with args.
22688 set dummy $ac_prog; ac_word=$2
22689 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22690 $as_echo_n "checking for $ac_word... " >&6; }
22691 if ${ac_cv_path_SETFILE+:} false; then :
22692   $as_echo_n "(cached) " >&6
22693 else
22694   case $SETFILE in
22695   [\\/]* | ?:[\\/]*)
22696   ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
22697   ;;
22698   *)
22699   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22700 for as_dir in $PATH
22701 do
22702   IFS=$as_save_IFS
22703   test -z "$as_dir" && as_dir=.
22704     for ac_exec_ext in '' $ac_executable_extensions; do
22705   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22706     ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
22707     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22708     break 2
22709   fi
22710 done
22711   done
22712 IFS=$as_save_IFS
22713 
22714   ;;
22715 esac
22716 fi
22717 SETFILE=$ac_cv_path_SETFILE
22718 if test -n "$SETFILE"; then
22719   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
22720 $as_echo "$SETFILE" >&6; }
22721 else
22722   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22723 $as_echo "no" >&6; }
22724 fi
22725 
22726 
22727   test -n "$SETFILE" && break
22728 done
22729 
22730     else
22731       # If it succeeded, then it was overridden by the user. We will use it
22732       # for the tool.
22733 
22734       # First remove it from the list of overridden variables, so we can test
22735       # for unknown variables in the end.
22736       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
22737 
22738       # Check if we try to supply an empty value
22739       if test "x$SETFILE" = x; then
22740         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool SETFILE= (no value)" >&5
22741 $as_echo "$as_me: Setting user supplied tool SETFILE= (no value)" >&6;}
22742         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SETFILE" >&5
22743 $as_echo_n "checking for SETFILE... " >&6; }
22744         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
22745 $as_echo "disabled" >&6; }
22746       else
22747         # Check if the provided tool contains a complete path.
22748         tool_specified="$SETFILE"
22749         tool_basename="${tool_specified##*/}"
22750         if test "x$tool_basename" = "x$tool_specified"; then
22751           # A command without a complete path is provided, search $PATH.
22752           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SETFILE=$tool_basename" >&5
22753 $as_echo "$as_me: Will search for user supplied tool SETFILE=$tool_basename" >&6;}
22754           # Extract the first word of "$tool_basename", so it can be a program name with args.
22755 set dummy $tool_basename; ac_word=$2
22756 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22757 $as_echo_n "checking for $ac_word... " >&6; }
22758 if ${ac_cv_path_SETFILE+:} false; then :
22759   $as_echo_n "(cached) " >&6
22760 else
22761   case $SETFILE in
22762   [\\/]* | ?:[\\/]*)
22763   ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
22764   ;;
22765   *)
22766   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22767 for as_dir in $PATH
22768 do
22769   IFS=$as_save_IFS
22770   test -z "$as_dir" && as_dir=.
22771     for ac_exec_ext in '' $ac_executable_extensions; do
22772   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22773     ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
22774     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22775     break 2
22776   fi
22777 done
22778   done
22779 IFS=$as_save_IFS
22780 
22781   ;;
22782 esac
22783 fi
22784 SETFILE=$ac_cv_path_SETFILE
22785 if test -n "$SETFILE"; then
22786   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
22787 $as_echo "$SETFILE" >&6; }
22788 else
22789   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22790 $as_echo "no" >&6; }
22791 fi
22792 
22793 
22794           if test "x$SETFILE" = x; then
22795             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
22796           fi
22797         else
22798           # Otherwise we believe it is a complete path. Use it as it is.
22799           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SETFILE=$tool_specified" >&5
22800 $as_echo "$as_me: Will use user supplied tool SETFILE=$tool_specified" >&6;}
22801           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SETFILE" >&5
22802 $as_echo_n "checking for SETFILE... " >&6; }
22803           if test ! -x "$tool_specified"; then
22804             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
22805 $as_echo "not found" >&6; }
22806             as_fn_error $? "User supplied tool SETFILE=$tool_specified does not exist or is not executable" "$LINENO" 5
22807           fi
22808           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
22809 $as_echo "$tool_specified" >&6; }
22810         fi
22811       fi
22812     fi
22813 
22814   fi
22815 
22816 
22817 
22818   if test "x$SETFILE" = x; then
22819     as_fn_error $? "Could not find required tool for SETFILE" "$LINENO" 5
22820   fi
22821 
22822 
22823   fi
22824 
22825 
22826   # Test if bash supports pipefail.
22827   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if bash supports pipefail" >&5
22828 $as_echo_n "checking if bash supports pipefail... " >&6; }
22829   if ${BASH} -c 'set -o pipefail'; then
22830     BASH_ARGS="$BASH_ARGS -o pipefail"
22831     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
22832 $as_echo "yes" >&6; }
22833   else
22834     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22835 $as_echo "no" >&6; }
22836   fi
22837 
22838   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if bash supports errexit (-e)" >&5
22839 $as_echo_n "checking if bash supports errexit (-e)... " >&6; }
22840   if ${BASH} -e -c 'true'; then
22841     BASH_ARGS="$BASH_ARGS -e"
22842     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
22843 $as_echo "yes" >&6; }
22844   else
22845     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22846 $as_echo "no" >&6; }
22847   fi
22848 
22849 
22850 
22851 
22852 # Check if pkg-config is available.
22853 
22854 
22855 if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then
22856         if test -n "$ac_tool_prefix"; then
22857   # Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args.
22858 set dummy ${ac_tool_prefix}pkg-config; ac_word=$2
22859 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22860 $as_echo_n "checking for $ac_word... " >&6; }
22861 if ${ac_cv_path_PKG_CONFIG+:} false; then :
22862   $as_echo_n "(cached) " >&6
22863 else
22864   case $PKG_CONFIG in
22865   [\\/]* | ?:[\\/]*)
22866   ac_cv_path_PKG_CONFIG="$PKG_CONFIG" # Let the user override the test with a path.
22867   ;;
22868   *)
22869   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22870 for as_dir in $PATH
22871 do
22872   IFS=$as_save_IFS
22873   test -z "$as_dir" && as_dir=.
22874     for ac_exec_ext in '' $ac_executable_extensions; do
22875   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22876     ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
22877     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22878     break 2
22879   fi
22880 done
22881   done
22882 IFS=$as_save_IFS
22883 
22884   ;;
22885 esac
22886 fi
22887 PKG_CONFIG=$ac_cv_path_PKG_CONFIG
22888 if test -n "$PKG_CONFIG"; then
22889   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
22890 $as_echo "$PKG_CONFIG" >&6; }
22891 else
22892   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22893 $as_echo "no" >&6; }
22894 fi
22895 
22896 
22897 fi
22898 if test -z "$ac_cv_path_PKG_CONFIG"; then
22899   ac_pt_PKG_CONFIG=$PKG_CONFIG
22900   # Extract the first word of "pkg-config", so it can be a program name with args.
22901 set dummy pkg-config; ac_word=$2
22902 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22903 $as_echo_n "checking for $ac_word... " >&6; }
22904 if ${ac_cv_path_ac_pt_PKG_CONFIG+:} false; then :
22905   $as_echo_n "(cached) " >&6
22906 else
22907   case $ac_pt_PKG_CONFIG in
22908   [\\/]* | ?:[\\/]*)
22909   ac_cv_path_ac_pt_PKG_CONFIG="$ac_pt_PKG_CONFIG" # Let the user override the test with a path.
22910   ;;
22911   *)
22912   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22913 for as_dir in $PATH
22914 do
22915   IFS=$as_save_IFS
22916   test -z "$as_dir" && as_dir=.
22917     for ac_exec_ext in '' $ac_executable_extensions; do
22918   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22919     ac_cv_path_ac_pt_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
22920     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22921     break 2
22922   fi
22923 done
22924   done
22925 IFS=$as_save_IFS
22926 
22927   ;;
22928 esac
22929 fi
22930 ac_pt_PKG_CONFIG=$ac_cv_path_ac_pt_PKG_CONFIG
22931 if test -n "$ac_pt_PKG_CONFIG"; then
22932   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_pt_PKG_CONFIG" >&5
22933 $as_echo "$ac_pt_PKG_CONFIG" >&6; }
22934 else
22935   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22936 $as_echo "no" >&6; }
22937 fi
22938 
22939   if test "x$ac_pt_PKG_CONFIG" = x; then
22940     PKG_CONFIG=""
22941   else
22942     case $cross_compiling:$ac_tool_warned in
22943 yes:)
22944 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
22945 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
22946 ac_tool_warned=yes ;;
22947 esac
22948     PKG_CONFIG=$ac_pt_PKG_CONFIG
22949   fi
22950 else
22951   PKG_CONFIG="$ac_cv_path_PKG_CONFIG"
22952 fi
22953 
22954 fi
22955 if test -n "$PKG_CONFIG"; then
22956         _pkg_min_version=0.9.0
22957         { $as_echo "$as_me:${as_lineno-$LINENO}: checking pkg-config is at least version $_pkg_min_version" >&5
22958 $as_echo_n "checking pkg-config is at least version $_pkg_min_version... " >&6; }
22959         if $PKG_CONFIG --atleast-pkgconfig-version $_pkg_min_version; then
22960                 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
22961 $as_echo "yes" >&6; }
22962         else
22963                 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22964 $as_echo "no" >&6; }
22965                 PKG_CONFIG=""
22966         fi
22967 
22968 fi
22969 
22970 # After basic tools have been setup, we can check build os specific details.
22971 
22972   ###############################################################################
22973 
22974   # Note that this is the build platform OS version!
22975 
22976   OS_VERSION="`uname -r | ${SED} 's!\.! !g' | ${SED} 's!-! !g'`"
22977   OS_VERSION_MAJOR="`${ECHO} ${OS_VERSION} | ${CUT} -f 1 -d ' '`"
22978   OS_VERSION_MINOR="`${ECHO} ${OS_VERSION} | ${CUT} -f 2 -d ' '`"
22979   OS_VERSION_MICRO="`${ECHO} ${OS_VERSION} | ${CUT} -f 3 -d ' '`"
22980 
22981 
22982 
22983 
22984 
22985 ###############################################################################
22986 #
22987 # Determine OpenJDK variants, options and version numbers.
22988 #
22989 ###############################################################################
22990 
22991 # We need build & target for this.
22992 
22993 
22994   ###############################################################################
22995   #
22996   # Should we build a JDK/JVM with headful support (ie a graphical ui)?
22997   # We always build headless support.
22998   #
22999   { $as_echo "$as_me:${as_lineno-$LINENO}: checking headful support" >&5
23000 $as_echo_n "checking headful support... " >&6; }
23001   # Check whether --enable-headful was given.
23002 if test "${enable_headful+set}" = set; then :
23003   enableval=$enable_headful; SUPPORT_HEADFUL=${enable_headful}
23004 else
23005   SUPPORT_HEADFUL=yes
23006 fi
23007 
23008 
23009   SUPPORT_HEADLESS=yes
23010   BUILD_HEADLESS="BUILD_HEADLESS:=true"
23011 
23012   if test "x$SUPPORT_HEADFUL" = xyes; then
23013     # We are building both headful and headless.
23014     headful_msg="include support for both headful and headless"
23015   fi
23016 
23017   if test "x$SUPPORT_HEADFUL" = xno; then
23018     # Thus we are building headless only.
23019     BUILD_HEADLESS="BUILD_HEADLESS:=true"
23020     headful_msg="headless only"
23021   fi
23022 
23023   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $headful_msg" >&5
23024 $as_echo "$headful_msg" >&6; }
23025 
23026 
23027 
23028 
23029 
23030   # Control wether Hotspot runs Queens test after build.
23031   # Check whether --enable-hotspot-test-in-build was given.
23032 if test "${enable_hotspot_test_in_build+set}" = set; then :
23033   enableval=$enable_hotspot_test_in_build;
23034 else
23035   enable_hotspot_test_in_build=no
23036 fi
23037 
23038   if test "x$enable_hotspot_test_in_build" = "xyes"; then
23039     TEST_IN_BUILD=true
23040   else
23041     TEST_IN_BUILD=false
23042   fi
23043 
23044 
23045   ###############################################################################
23046   #
23047   # Choose cacerts source file
23048   #
23049 
23050 # Check whether --with-cacerts-file was given.
23051 if test "${with_cacerts_file+set}" = set; then :
23052   withval=$with_cacerts_file;
23053 fi
23054 
23055   if test "x$with_cacerts_file" != x; then
23056     CACERTS_FILE=$with_cacerts_file
23057   fi
23058 
23059 
23060   ###############################################################################
23061   #
23062   # Enable or disable unlimited crypto
23063   #
23064   # Check whether --enable-unlimited-crypto was given.
23065 if test "${enable_unlimited_crypto+set}" = set; then :
23066   enableval=$enable_unlimited_crypto;
23067 else
23068   enable_unlimited_crypto=no
23069 fi
23070 
23071   if test "x$enable_unlimited_crypto" = "xyes"; then
23072     UNLIMITED_CRYPTO=true
23073   else
23074     UNLIMITED_CRYPTO=false
23075   fi
23076 
23077 
23078   ###############################################################################
23079   #
23080   # Enable or disable the elliptic curve crypto implementation
23081   #
23082 
23083 
23084   ###############################################################################
23085   #
23086   # Compress jars
23087   #
23088   COMPRESS_JARS=false
23089 
23090 
23091 
23092 
23093   # Source the version numbers
23094   . $AUTOCONF_DIR/version-numbers
23095 
23096   # Get the settings from parameters
23097 
23098 # Check whether --with-milestone was given.
23099 if test "${with_milestone+set}" = set; then :
23100   withval=$with_milestone;
23101 fi
23102 
23103   if test "x$with_milestone" = xyes; then
23104     as_fn_error $? "Milestone must have a value" "$LINENO" 5
23105   elif test "x$with_milestone" != x; then
23106     MILESTONE="$with_milestone"
23107   fi
23108   if test "x$MILESTONE" = x; then
23109     MILESTONE=internal
23110   fi
23111 
23112 
23113 # Check whether --with-update-version was given.
23114 if test "${with_update_version+set}" = set; then :
23115   withval=$with_update_version;
23116 fi
23117 
23118   if test "x$with_update_version" = xyes; then
23119     as_fn_error $? "Update version must have a value" "$LINENO" 5
23120   elif test "x$with_update_version" != x; then
23121     JDK_UPDATE_VERSION="$with_update_version"
23122     # On macosx 10.7, it's not possible to set --with-update-version=0X due
23123     # to a bug in expr (which reduces it to just X). To work around this, we
23124     # always add a 0 to one digit update versions.
23125     if test "${#JDK_UPDATE_VERSION}" = "1"; then
23126       JDK_UPDATE_VERSION="0${JDK_UPDATE_VERSION}"
23127     fi
23128   fi
23129 
23130 
23131 # Check whether --with-user-release-suffix was given.
23132 if test "${with_user_release_suffix+set}" = set; then :
23133   withval=$with_user_release_suffix;
23134 fi
23135 
23136   if test "x$with_user_release_suffix" = xyes; then
23137     as_fn_error $? "Release suffix must have a value" "$LINENO" 5
23138   elif test "x$with_user_release_suffix" != x; then
23139     USER_RELEASE_SUFFIX="$with_user_release_suffix"
23140   fi
23141 
23142 
23143 # Check whether --with-build-number was given.
23144 if test "${with_build_number+set}" = set; then :
23145   withval=$with_build_number;
23146 fi
23147 
23148   if test "x$with_build_number" = xyes; then
23149     as_fn_error $? "Build number must have a value" "$LINENO" 5
23150   elif test "x$with_build_number" != x; then
23151     JDK_BUILD_NUMBER="$with_build_number"
23152   fi
23153   # Define default USER_RELEASE_SUFFIX if BUILD_NUMBER and USER_RELEASE_SUFFIX are not set
23154   if test "x$JDK_BUILD_NUMBER" = x; then
23155     JDK_BUILD_NUMBER=b00
23156     if test "x$USER_RELEASE_SUFFIX" = x; then
23157       BUILD_DATE=`date '+%Y_%m_%d_%H_%M'`
23158       # Avoid [:alnum:] since it depends on the locale.
23159       CLEAN_USERNAME=`echo "$USER" | $TR -d -c 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'`
23160       USER_RELEASE_SUFFIX=`echo "${CLEAN_USERNAME}_${BUILD_DATE}" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23161     fi
23162   fi
23163 
23164   # Now set the JDK version, milestone, build number etc.
23165 
23166 
23167 
23168 
23169 
23170 
23171 
23172 
23173 
23174 
23175 
23176 
23177 
23178 
23179 
23180 
23181 # Check whether --with-copyright-year was given.
23182 if test "${with_copyright_year+set}" = set; then :
23183   withval=$with_copyright_year;
23184 fi
23185 
23186   if test "x$with_copyright_year" = xyes; then
23187     as_fn_error $? "Copyright year must have a value" "$LINENO" 5
23188   elif test "x$with_copyright_year" != x; then
23189     COPYRIGHT_YEAR="$with_copyright_year"
23190   else
23191     COPYRIGHT_YEAR=`date +'%Y'`
23192   fi
23193 
23194 
23195   if test "x$JDK_UPDATE_VERSION" != x; then
23196     JDK_VERSION="${JDK_MAJOR_VERSION}.${JDK_MINOR_VERSION}.${JDK_MICRO_VERSION}_${JDK_UPDATE_VERSION}"
23197   else
23198     JDK_VERSION="${JDK_MAJOR_VERSION}.${JDK_MINOR_VERSION}.${JDK_MICRO_VERSION}"
23199   fi
23200 
23201 
23202   COOKED_BUILD_NUMBER=`$ECHO $JDK_BUILD_NUMBER | $SED -e 's/^b//' -e 's/^0//'`
23203 
23204 
23205 
23206 ###############################################################################
23207 #
23208 # Setup BootJDK, used to bootstrap the build.
23209 #
23210 ###############################################################################
23211 
23212 
23213   BOOT_JDK_FOUND=no
23214 
23215 # Check whether --with-boot-jdk was given.
23216 if test "${with_boot_jdk+set}" = set; then :
23217   withval=$with_boot_jdk;
23218 fi
23219 
23220 
23221   # We look for the Boot JDK through various means, going from more certain to
23222   # more of a guess-work. After each test, BOOT_JDK_FOUND is set to "yes" if
23223   # we detected something (if so, the path to the jdk is in BOOT_JDK). But we
23224   # must check if this is indeed valid; otherwise we'll continue looking.
23225 
23226   # Test: Is bootjdk explicitely set by command line arguments?
23227 
23228   if test "x$BOOT_JDK_FOUND" = xno; then
23229     # Now execute the test
23230 
23231   if test "x$with_boot_jdk" != x; then
23232     BOOT_JDK=$with_boot_jdk
23233     BOOT_JDK_FOUND=maybe
23234     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using configure arguments" >&5
23235 $as_echo "$as_me: Found potential Boot JDK using configure arguments" >&6;}
23236   fi
23237 
23238 
23239     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23240     if test "x$BOOT_JDK_FOUND" = xmaybe; then
23241       # Do we have a bin/java?
23242       if test ! -x "$BOOT_JDK/bin/java"; then
23243         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23244 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23245         BOOT_JDK_FOUND=no
23246       else
23247         # Do we have a bin/javac?
23248         if test ! -x "$BOOT_JDK/bin/javac"; then
23249           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23250 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23251           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23252 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23253           BOOT_JDK_FOUND=no
23254         else
23255           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23256           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23257 
23258           # Extra M4 quote needed to protect [] in grep expression.
23259           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
23260           if test "x$FOUND_CORRECT_VERSION" = x; then
23261             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23262 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23263             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
23264 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
23265             BOOT_JDK_FOUND=no
23266           else
23267             # We're done! :-)
23268             BOOT_JDK_FOUND=yes
23269 
23270   # Only process if variable expands to non-empty
23271 
23272   if test "x$BOOT_JDK" != x; then
23273     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23274 
23275   # Input might be given as Windows format, start by converting to
23276   # unix format.
23277   path="$BOOT_JDK"
23278   new_path=`$CYGPATH -u "$path"`
23279 
23280   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23281   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23282   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23283   # "foo.exe" is OK but "foo" is an error.
23284   #
23285   # This test is therefore slightly more accurate than "test -f" to check for file precense.
23286   # It is also a way to make sure we got the proper file name for the real test later on.
23287   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23288   if test "x$test_shortpath" = x; then
23289     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23290 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23291     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23292   fi
23293 
23294   # Call helper function which possibly converts this using DOS-style short mode.
23295   # If so, the updated path is stored in $new_path.
23296 
23297   input_path="$new_path"
23298   # Check if we need to convert this using DOS-style short mode. If the path
23299   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23300   # take no chances and rewrite it.
23301   # Note: m4 eats our [], so we need to use [ and ] instead.
23302   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23303   if test "x$has_forbidden_chars" != x; then
23304     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23305     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23306     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23307     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23308       # Going to short mode and back again did indeed matter. Since short mode is
23309       # case insensitive, let's make it lowercase to improve readability.
23310       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23311       # Now convert it back to Unix-style (cygpath)
23312       input_path=`$CYGPATH -u "$shortmode_path"`
23313       new_path="$input_path"
23314     fi
23315   fi
23316 
23317   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23318   if test "x$test_cygdrive_prefix" = x; then
23319     # As a simple fix, exclude /usr/bin since it's not a real path.
23320     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23321       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23322       # a path prefixed by /cygdrive for fixpath to work.
23323       new_path="$CYGWIN_ROOT_PATH$input_path"
23324     fi
23325   fi
23326 
23327 
23328   if test "x$path" != "x$new_path"; then
23329     BOOT_JDK="$new_path"
23330     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23331 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23332   fi
23333 
23334     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23335 
23336   path="$BOOT_JDK"
23337   has_colon=`$ECHO $path | $GREP ^.:`
23338   new_path="$path"
23339   if test "x$has_colon" = x; then
23340     # Not in mixed or Windows style, start by that.
23341     new_path=`cmd //c echo $path`
23342   fi
23343 
23344 
23345   input_path="$new_path"
23346   # Check if we need to convert this using DOS-style short mode. If the path
23347   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23348   # take no chances and rewrite it.
23349   # Note: m4 eats our [], so we need to use [ and ] instead.
23350   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23351   if test "x$has_forbidden_chars" != x; then
23352     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23353     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23354   fi
23355 
23356 
23357   windows_path="$new_path"
23358   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23359     unix_path=`$CYGPATH -u "$windows_path"`
23360     new_path="$unix_path"
23361   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23362     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23363     new_path="$unix_path"
23364   fi
23365 
23366   if test "x$path" != "x$new_path"; then
23367     BOOT_JDK="$new_path"
23368     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23369 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23370   fi
23371 
23372   # Save the first 10 bytes of this path to the storage, so fixpath can work.
23373   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23374 
23375     else
23376       # We're on a unix platform. Hooray! :)
23377       path="$BOOT_JDK"
23378       has_space=`$ECHO "$path" | $GREP " "`
23379       if test "x$has_space" != x; then
23380         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23381 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23382         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23383       fi
23384 
23385       # Use eval to expand a potential ~
23386       eval path="$path"
23387       if test ! -f "$path" && test ! -d "$path"; then
23388         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23389       fi
23390 
23391       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23392     fi
23393   fi
23394 
23395             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23396 $as_echo_n "checking for Boot JDK... " >&6; }
23397             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23398 $as_echo "$BOOT_JDK" >&6; }
23399             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23400 $as_echo_n "checking Boot JDK version... " >&6; }
23401             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
23402             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23403 $as_echo "$BOOT_JDK_VERSION" >&6; }
23404           fi # end check jdk version
23405         fi # end check javac
23406       fi # end check java
23407     fi # end check boot jdk found
23408   fi
23409 
23410   if test "x$with_boot_jdk" != x && test "x$BOOT_JDK_FOUND" = xno; then
23411     # Having specified an argument which is incorrect will produce an instant failure;
23412     # we should not go on looking
23413     as_fn_error $? "The path given by --with-boot-jdk does not contain a valid Boot JDK" "$LINENO" 5
23414   fi
23415 
23416   # Test: On MacOS X, can we find a boot jdk using /usr/libexec/java_home?
23417 
23418   if test "x$BOOT_JDK_FOUND" = xno; then
23419     # Now execute the test
23420 
23421   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
23422     # First check at user selected default
23423 
23424   if test "x$BOOT_JDK_FOUND" = xno; then
23425     # Now execute the test
23426 
23427   if test -x /usr/libexec/java_home; then
23428     BOOT_JDK=`/usr/libexec/java_home `
23429     BOOT_JDK_FOUND=maybe
23430     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home " >&5
23431 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home " >&6;}
23432   fi
23433 
23434 
23435     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23436     if test "x$BOOT_JDK_FOUND" = xmaybe; then
23437       # Do we have a bin/java?
23438       if test ! -x "$BOOT_JDK/bin/java"; then
23439         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23440 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23441         BOOT_JDK_FOUND=no
23442       else
23443         # Do we have a bin/javac?
23444         if test ! -x "$BOOT_JDK/bin/javac"; then
23445           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23446 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23447           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23448 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23449           BOOT_JDK_FOUND=no
23450         else
23451           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23452           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23453 
23454           # Extra M4 quote needed to protect [] in grep expression.
23455           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
23456           if test "x$FOUND_CORRECT_VERSION" = x; then
23457             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23458 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23459             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
23460 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
23461             BOOT_JDK_FOUND=no
23462           else
23463             # We're done! :-)
23464             BOOT_JDK_FOUND=yes
23465 
23466   # Only process if variable expands to non-empty
23467 
23468   if test "x$BOOT_JDK" != x; then
23469     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23470 
23471   # Input might be given as Windows format, start by converting to
23472   # unix format.
23473   path="$BOOT_JDK"
23474   new_path=`$CYGPATH -u "$path"`
23475 
23476   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23477   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23478   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23479   # "foo.exe" is OK but "foo" is an error.
23480   #
23481   # This test is therefore slightly more accurate than "test -f" to check for file precense.
23482   # It is also a way to make sure we got the proper file name for the real test later on.
23483   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23484   if test "x$test_shortpath" = x; then
23485     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23486 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23487     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23488   fi
23489 
23490   # Call helper function which possibly converts this using DOS-style short mode.
23491   # If so, the updated path is stored in $new_path.
23492 
23493   input_path="$new_path"
23494   # Check if we need to convert this using DOS-style short mode. If the path
23495   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23496   # take no chances and rewrite it.
23497   # Note: m4 eats our [], so we need to use [ and ] instead.
23498   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23499   if test "x$has_forbidden_chars" != x; then
23500     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23501     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23502     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23503     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23504       # Going to short mode and back again did indeed matter. Since short mode is
23505       # case insensitive, let's make it lowercase to improve readability.
23506       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23507       # Now convert it back to Unix-style (cygpath)
23508       input_path=`$CYGPATH -u "$shortmode_path"`
23509       new_path="$input_path"
23510     fi
23511   fi
23512 
23513   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23514   if test "x$test_cygdrive_prefix" = x; then
23515     # As a simple fix, exclude /usr/bin since it's not a real path.
23516     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23517       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23518       # a path prefixed by /cygdrive for fixpath to work.
23519       new_path="$CYGWIN_ROOT_PATH$input_path"
23520     fi
23521   fi
23522 
23523 
23524   if test "x$path" != "x$new_path"; then
23525     BOOT_JDK="$new_path"
23526     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23527 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23528   fi
23529 
23530     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23531 
23532   path="$BOOT_JDK"
23533   has_colon=`$ECHO $path | $GREP ^.:`
23534   new_path="$path"
23535   if test "x$has_colon" = x; then
23536     # Not in mixed or Windows style, start by that.
23537     new_path=`cmd //c echo $path`
23538   fi
23539 
23540 
23541   input_path="$new_path"
23542   # Check if we need to convert this using DOS-style short mode. If the path
23543   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23544   # take no chances and rewrite it.
23545   # Note: m4 eats our [], so we need to use [ and ] instead.
23546   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23547   if test "x$has_forbidden_chars" != x; then
23548     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23549     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23550   fi
23551 
23552 
23553   windows_path="$new_path"
23554   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23555     unix_path=`$CYGPATH -u "$windows_path"`
23556     new_path="$unix_path"
23557   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23558     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23559     new_path="$unix_path"
23560   fi
23561 
23562   if test "x$path" != "x$new_path"; then
23563     BOOT_JDK="$new_path"
23564     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23565 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23566   fi
23567 
23568   # Save the first 10 bytes of this path to the storage, so fixpath can work.
23569   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23570 
23571     else
23572       # We're on a unix platform. Hooray! :)
23573       path="$BOOT_JDK"
23574       has_space=`$ECHO "$path" | $GREP " "`
23575       if test "x$has_space" != x; then
23576         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23577 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23578         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23579       fi
23580 
23581       # Use eval to expand a potential ~
23582       eval path="$path"
23583       if test ! -f "$path" && test ! -d "$path"; then
23584         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23585       fi
23586 
23587       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23588     fi
23589   fi
23590 
23591             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23592 $as_echo_n "checking for Boot JDK... " >&6; }
23593             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23594 $as_echo "$BOOT_JDK" >&6; }
23595             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23596 $as_echo_n "checking Boot JDK version... " >&6; }
23597             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
23598             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23599 $as_echo "$BOOT_JDK_VERSION" >&6; }
23600           fi # end check jdk version
23601         fi # end check javac
23602       fi # end check java
23603     fi # end check boot jdk found
23604   fi
23605 
23606     # If that did not work out (e.g. too old), try explicit versions instead
23607 
23608   if test "x$BOOT_JDK_FOUND" = xno; then
23609     # Now execute the test
23610 
23611   if test -x /usr/libexec/java_home; then
23612     BOOT_JDK=`/usr/libexec/java_home -v 1.9`
23613     BOOT_JDK_FOUND=maybe
23614     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home -v 1.9" >&5
23615 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home -v 1.9" >&6;}
23616   fi
23617 
23618 
23619     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23620     if test "x$BOOT_JDK_FOUND" = xmaybe; then
23621       # Do we have a bin/java?
23622       if test ! -x "$BOOT_JDK/bin/java"; then
23623         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23624 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23625         BOOT_JDK_FOUND=no
23626       else
23627         # Do we have a bin/javac?
23628         if test ! -x "$BOOT_JDK/bin/javac"; then
23629           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23630 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23631           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23632 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23633           BOOT_JDK_FOUND=no
23634         else
23635           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23636           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23637 
23638           # Extra M4 quote needed to protect [] in grep expression.
23639           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
23640           if test "x$FOUND_CORRECT_VERSION" = x; then
23641             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23642 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23643             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
23644 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
23645             BOOT_JDK_FOUND=no
23646           else
23647             # We're done! :-)
23648             BOOT_JDK_FOUND=yes
23649 
23650   # Only process if variable expands to non-empty
23651 
23652   if test "x$BOOT_JDK" != x; then
23653     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23654 
23655   # Input might be given as Windows format, start by converting to
23656   # unix format.
23657   path="$BOOT_JDK"
23658   new_path=`$CYGPATH -u "$path"`
23659 
23660   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23661   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23662   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23663   # "foo.exe" is OK but "foo" is an error.
23664   #
23665   # This test is therefore slightly more accurate than "test -f" to check for file precense.
23666   # It is also a way to make sure we got the proper file name for the real test later on.
23667   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23668   if test "x$test_shortpath" = x; then
23669     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23670 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23671     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23672   fi
23673 
23674   # Call helper function which possibly converts this using DOS-style short mode.
23675   # If so, the updated path is stored in $new_path.
23676 
23677   input_path="$new_path"
23678   # Check if we need to convert this using DOS-style short mode. If the path
23679   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23680   # take no chances and rewrite it.
23681   # Note: m4 eats our [], so we need to use [ and ] instead.
23682   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23683   if test "x$has_forbidden_chars" != x; then
23684     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23685     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23686     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23687     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23688       # Going to short mode and back again did indeed matter. Since short mode is
23689       # case insensitive, let's make it lowercase to improve readability.
23690       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23691       # Now convert it back to Unix-style (cygpath)
23692       input_path=`$CYGPATH -u "$shortmode_path"`
23693       new_path="$input_path"
23694     fi
23695   fi
23696 
23697   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23698   if test "x$test_cygdrive_prefix" = x; then
23699     # As a simple fix, exclude /usr/bin since it's not a real path.
23700     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23701       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23702       # a path prefixed by /cygdrive for fixpath to work.
23703       new_path="$CYGWIN_ROOT_PATH$input_path"
23704     fi
23705   fi
23706 
23707 
23708   if test "x$path" != "x$new_path"; then
23709     BOOT_JDK="$new_path"
23710     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23711 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23712   fi
23713 
23714     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23715 
23716   path="$BOOT_JDK"
23717   has_colon=`$ECHO $path | $GREP ^.:`
23718   new_path="$path"
23719   if test "x$has_colon" = x; then
23720     # Not in mixed or Windows style, start by that.
23721     new_path=`cmd //c echo $path`
23722   fi
23723 
23724 
23725   input_path="$new_path"
23726   # Check if we need to convert this using DOS-style short mode. If the path
23727   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23728   # take no chances and rewrite it.
23729   # Note: m4 eats our [], so we need to use [ and ] instead.
23730   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23731   if test "x$has_forbidden_chars" != x; then
23732     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23733     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23734   fi
23735 
23736 
23737   windows_path="$new_path"
23738   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23739     unix_path=`$CYGPATH -u "$windows_path"`
23740     new_path="$unix_path"
23741   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23742     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23743     new_path="$unix_path"
23744   fi
23745 
23746   if test "x$path" != "x$new_path"; then
23747     BOOT_JDK="$new_path"
23748     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23749 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23750   fi
23751 
23752   # Save the first 10 bytes of this path to the storage, so fixpath can work.
23753   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23754 
23755     else
23756       # We're on a unix platform. Hooray! :)
23757       path="$BOOT_JDK"
23758       has_space=`$ECHO "$path" | $GREP " "`
23759       if test "x$has_space" != 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 $? "Spaces are not allowed in this path." "$LINENO" 5
23763       fi
23764 
23765       # Use eval to expand a potential ~
23766       eval path="$path"
23767       if test ! -f "$path" && test ! -d "$path"; then
23768         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23769       fi
23770 
23771       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23772     fi
23773   fi
23774 
23775             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23776 $as_echo_n "checking for Boot JDK... " >&6; }
23777             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23778 $as_echo "$BOOT_JDK" >&6; }
23779             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23780 $as_echo_n "checking Boot JDK version... " >&6; }
23781             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
23782             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23783 $as_echo "$BOOT_JDK_VERSION" >&6; }
23784           fi # end check jdk version
23785         fi # end check javac
23786       fi # end check java
23787     fi # end check boot jdk found
23788   fi
23789 
23790 
23791   if test "x$BOOT_JDK_FOUND" = xno; then
23792     # Now execute the test
23793 
23794   if test -x /usr/libexec/java_home; then
23795     BOOT_JDK=`/usr/libexec/java_home -v 1.8`
23796     BOOT_JDK_FOUND=maybe
23797     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home -v 1.8" >&5
23798 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home -v 1.8" >&6;}
23799   fi
23800 
23801 
23802     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23803     if test "x$BOOT_JDK_FOUND" = xmaybe; then
23804       # Do we have a bin/java?
23805       if test ! -x "$BOOT_JDK/bin/java"; then
23806         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23807 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23808         BOOT_JDK_FOUND=no
23809       else
23810         # Do we have a bin/javac?
23811         if test ! -x "$BOOT_JDK/bin/javac"; then
23812           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23813 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23814           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23815 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23816           BOOT_JDK_FOUND=no
23817         else
23818           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23819           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23820 
23821           # Extra M4 quote needed to protect [] in grep expression.
23822           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
23823           if test "x$FOUND_CORRECT_VERSION" = x; then
23824             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23825 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23826             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
23827 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
23828             BOOT_JDK_FOUND=no
23829           else
23830             # We're done! :-)
23831             BOOT_JDK_FOUND=yes
23832 
23833   # Only process if variable expands to non-empty
23834 
23835   if test "x$BOOT_JDK" != x; then
23836     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23837 
23838   # Input might be given as Windows format, start by converting to
23839   # unix format.
23840   path="$BOOT_JDK"
23841   new_path=`$CYGPATH -u "$path"`
23842 
23843   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23844   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23845   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23846   # "foo.exe" is OK but "foo" is an error.
23847   #
23848   # This test is therefore slightly more accurate than "test -f" to check for file precense.
23849   # It is also a way to make sure we got the proper file name for the real test later on.
23850   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23851   if test "x$test_shortpath" = x; then
23852     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23853 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23854     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23855   fi
23856 
23857   # Call helper function which possibly converts this using DOS-style short mode.
23858   # If so, the updated path is stored in $new_path.
23859 
23860   input_path="$new_path"
23861   # Check if we need to convert this using DOS-style short mode. If the path
23862   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23863   # take no chances and rewrite it.
23864   # Note: m4 eats our [], so we need to use [ and ] instead.
23865   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23866   if test "x$has_forbidden_chars" != x; then
23867     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23868     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23869     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23870     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23871       # Going to short mode and back again did indeed matter. Since short mode is
23872       # case insensitive, let's make it lowercase to improve readability.
23873       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23874       # Now convert it back to Unix-style (cygpath)
23875       input_path=`$CYGPATH -u "$shortmode_path"`
23876       new_path="$input_path"
23877     fi
23878   fi
23879 
23880   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23881   if test "x$test_cygdrive_prefix" = x; then
23882     # As a simple fix, exclude /usr/bin since it's not a real path.
23883     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23884       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23885       # a path prefixed by /cygdrive for fixpath to work.
23886       new_path="$CYGWIN_ROOT_PATH$input_path"
23887     fi
23888   fi
23889 
23890 
23891   if test "x$path" != "x$new_path"; then
23892     BOOT_JDK="$new_path"
23893     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23894 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23895   fi
23896 
23897     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23898 
23899   path="$BOOT_JDK"
23900   has_colon=`$ECHO $path | $GREP ^.:`
23901   new_path="$path"
23902   if test "x$has_colon" = x; then
23903     # Not in mixed or Windows style, start by that.
23904     new_path=`cmd //c echo $path`
23905   fi
23906 
23907 
23908   input_path="$new_path"
23909   # Check if we need to convert this using DOS-style short mode. If the path
23910   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23911   # take no chances and rewrite it.
23912   # Note: m4 eats our [], so we need to use [ and ] instead.
23913   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23914   if test "x$has_forbidden_chars" != x; then
23915     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23916     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23917   fi
23918 
23919 
23920   windows_path="$new_path"
23921   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23922     unix_path=`$CYGPATH -u "$windows_path"`
23923     new_path="$unix_path"
23924   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23925     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23926     new_path="$unix_path"
23927   fi
23928 
23929   if test "x$path" != "x$new_path"; then
23930     BOOT_JDK="$new_path"
23931     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23932 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23933   fi
23934 
23935   # Save the first 10 bytes of this path to the storage, so fixpath can work.
23936   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23937 
23938     else
23939       # We're on a unix platform. Hooray! :)
23940       path="$BOOT_JDK"
23941       has_space=`$ECHO "$path" | $GREP " "`
23942       if test "x$has_space" != x; then
23943         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23944 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23945         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23946       fi
23947 
23948       # Use eval to expand a potential ~
23949       eval path="$path"
23950       if test ! -f "$path" && test ! -d "$path"; then
23951         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23952       fi
23953 
23954       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23955     fi
23956   fi
23957 
23958             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23959 $as_echo_n "checking for Boot JDK... " >&6; }
23960             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23961 $as_echo "$BOOT_JDK" >&6; }
23962             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23963 $as_echo_n "checking Boot JDK version... " >&6; }
23964             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
23965             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23966 $as_echo "$BOOT_JDK_VERSION" >&6; }
23967           fi # end check jdk version
23968         fi # end check javac
23969       fi # end check java
23970     fi # end check boot jdk found
23971   fi
23972 
23973 
23974   if test "x$BOOT_JDK_FOUND" = xno; then
23975     # Now execute the test
23976 
23977   if test -x /usr/libexec/java_home; then
23978     BOOT_JDK=`/usr/libexec/java_home -v 1.7`
23979     BOOT_JDK_FOUND=maybe
23980     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home -v 1.7" >&5
23981 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home -v 1.7" >&6;}
23982   fi
23983 
23984 
23985     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23986     if test "x$BOOT_JDK_FOUND" = xmaybe; then
23987       # Do we have a bin/java?
23988       if test ! -x "$BOOT_JDK/bin/java"; then
23989         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23990 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23991         BOOT_JDK_FOUND=no
23992       else
23993         # Do we have a bin/javac?
23994         if test ! -x "$BOOT_JDK/bin/javac"; then
23995           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23996 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23997           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23998 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23999           BOOT_JDK_FOUND=no
24000         else
24001           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24002           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24003 
24004           # Extra M4 quote needed to protect [] in grep expression.
24005           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
24006           if test "x$FOUND_CORRECT_VERSION" = x; then
24007             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24008 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24009             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
24010 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
24011             BOOT_JDK_FOUND=no
24012           else
24013             # We're done! :-)
24014             BOOT_JDK_FOUND=yes
24015 
24016   # Only process if variable expands to non-empty
24017 
24018   if test "x$BOOT_JDK" != x; then
24019     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24020 
24021   # Input might be given as Windows format, start by converting to
24022   # unix format.
24023   path="$BOOT_JDK"
24024   new_path=`$CYGPATH -u "$path"`
24025 
24026   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24027   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24028   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24029   # "foo.exe" is OK but "foo" is an error.
24030   #
24031   # This test is therefore slightly more accurate than "test -f" to check for file precense.
24032   # It is also a way to make sure we got the proper file name for the real test later on.
24033   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24034   if test "x$test_shortpath" = x; then
24035     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24036 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24037     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24038   fi
24039 
24040   # Call helper function which possibly converts this using DOS-style short mode.
24041   # If so, the updated path is stored in $new_path.
24042 
24043   input_path="$new_path"
24044   # Check if we need to convert this using DOS-style short mode. If the path
24045   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24046   # take no chances and rewrite it.
24047   # Note: m4 eats our [], so we need to use [ and ] instead.
24048   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24049   if test "x$has_forbidden_chars" != x; then
24050     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24051     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24052     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24053     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24054       # Going to short mode and back again did indeed matter. Since short mode is
24055       # case insensitive, let's make it lowercase to improve readability.
24056       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24057       # Now convert it back to Unix-style (cygpath)
24058       input_path=`$CYGPATH -u "$shortmode_path"`
24059       new_path="$input_path"
24060     fi
24061   fi
24062 
24063   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24064   if test "x$test_cygdrive_prefix" = x; then
24065     # As a simple fix, exclude /usr/bin since it's not a real path.
24066     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24067       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24068       # a path prefixed by /cygdrive for fixpath to work.
24069       new_path="$CYGWIN_ROOT_PATH$input_path"
24070     fi
24071   fi
24072 
24073 
24074   if test "x$path" != "x$new_path"; then
24075     BOOT_JDK="$new_path"
24076     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24077 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24078   fi
24079 
24080     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24081 
24082   path="$BOOT_JDK"
24083   has_colon=`$ECHO $path | $GREP ^.:`
24084   new_path="$path"
24085   if test "x$has_colon" = x; then
24086     # Not in mixed or Windows style, start by that.
24087     new_path=`cmd //c echo $path`
24088   fi
24089 
24090 
24091   input_path="$new_path"
24092   # Check if we need to convert this using DOS-style short mode. If the path
24093   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24094   # take no chances and rewrite it.
24095   # Note: m4 eats our [], so we need to use [ and ] instead.
24096   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24097   if test "x$has_forbidden_chars" != x; then
24098     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24099     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24100   fi
24101 
24102 
24103   windows_path="$new_path"
24104   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24105     unix_path=`$CYGPATH -u "$windows_path"`
24106     new_path="$unix_path"
24107   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24108     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24109     new_path="$unix_path"
24110   fi
24111 
24112   if test "x$path" != "x$new_path"; then
24113     BOOT_JDK="$new_path"
24114     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24115 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24116   fi
24117 
24118   # Save the first 10 bytes of this path to the storage, so fixpath can work.
24119   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24120 
24121     else
24122       # We're on a unix platform. Hooray! :)
24123       path="$BOOT_JDK"
24124       has_space=`$ECHO "$path" | $GREP " "`
24125       if test "x$has_space" != x; then
24126         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24127 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24128         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24129       fi
24130 
24131       # Use eval to expand a potential ~
24132       eval path="$path"
24133       if test ! -f "$path" && test ! -d "$path"; then
24134         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24135       fi
24136 
24137       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24138     fi
24139   fi
24140 
24141             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24142 $as_echo_n "checking for Boot JDK... " >&6; }
24143             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24144 $as_echo "$BOOT_JDK" >&6; }
24145             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24146 $as_echo_n "checking Boot JDK version... " >&6; }
24147             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
24148             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24149 $as_echo "$BOOT_JDK_VERSION" >&6; }
24150           fi # end check jdk version
24151         fi # end check javac
24152       fi # end check java
24153     fi # end check boot jdk found
24154   fi
24155 
24156   fi
24157 
24158 
24159     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24160     if test "x$BOOT_JDK_FOUND" = xmaybe; then
24161       # Do we have a bin/java?
24162       if test ! -x "$BOOT_JDK/bin/java"; then
24163         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24164 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24165         BOOT_JDK_FOUND=no
24166       else
24167         # Do we have a bin/javac?
24168         if test ! -x "$BOOT_JDK/bin/javac"; then
24169           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24170 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24171           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24172 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24173           BOOT_JDK_FOUND=no
24174         else
24175           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24176           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24177 
24178           # Extra M4 quote needed to protect [] in grep expression.
24179           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
24180           if test "x$FOUND_CORRECT_VERSION" = x; then
24181             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24182 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24183             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
24184 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
24185             BOOT_JDK_FOUND=no
24186           else
24187             # We're done! :-)
24188             BOOT_JDK_FOUND=yes
24189 
24190   # Only process if variable expands to non-empty
24191 
24192   if test "x$BOOT_JDK" != x; then
24193     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24194 
24195   # Input might be given as Windows format, start by converting to
24196   # unix format.
24197   path="$BOOT_JDK"
24198   new_path=`$CYGPATH -u "$path"`
24199 
24200   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24201   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24202   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24203   # "foo.exe" is OK but "foo" is an error.
24204   #
24205   # This test is therefore slightly more accurate than "test -f" to check for file precense.
24206   # It is also a way to make sure we got the proper file name for the real test later on.
24207   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24208   if test "x$test_shortpath" = x; then
24209     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24210 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24211     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24212   fi
24213 
24214   # Call helper function which possibly converts this using DOS-style short mode.
24215   # If so, the updated path is stored in $new_path.
24216 
24217   input_path="$new_path"
24218   # Check if we need to convert this using DOS-style short mode. If the path
24219   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24220   # take no chances and rewrite it.
24221   # Note: m4 eats our [], so we need to use [ and ] instead.
24222   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24223   if test "x$has_forbidden_chars" != x; then
24224     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24225     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24226     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24227     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24228       # Going to short mode and back again did indeed matter. Since short mode is
24229       # case insensitive, let's make it lowercase to improve readability.
24230       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24231       # Now convert it back to Unix-style (cygpath)
24232       input_path=`$CYGPATH -u "$shortmode_path"`
24233       new_path="$input_path"
24234     fi
24235   fi
24236 
24237   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24238   if test "x$test_cygdrive_prefix" = x; then
24239     # As a simple fix, exclude /usr/bin since it's not a real path.
24240     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24241       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24242       # a path prefixed by /cygdrive for fixpath to work.
24243       new_path="$CYGWIN_ROOT_PATH$input_path"
24244     fi
24245   fi
24246 
24247 
24248   if test "x$path" != "x$new_path"; then
24249     BOOT_JDK="$new_path"
24250     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24251 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24252   fi
24253 
24254     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24255 
24256   path="$BOOT_JDK"
24257   has_colon=`$ECHO $path | $GREP ^.:`
24258   new_path="$path"
24259   if test "x$has_colon" = x; then
24260     # Not in mixed or Windows style, start by that.
24261     new_path=`cmd //c echo $path`
24262   fi
24263 
24264 
24265   input_path="$new_path"
24266   # Check if we need to convert this using DOS-style short mode. If the path
24267   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24268   # take no chances and rewrite it.
24269   # Note: m4 eats our [], so we need to use [ and ] instead.
24270   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24271   if test "x$has_forbidden_chars" != x; then
24272     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24273     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24274   fi
24275 
24276 
24277   windows_path="$new_path"
24278   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24279     unix_path=`$CYGPATH -u "$windows_path"`
24280     new_path="$unix_path"
24281   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24282     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24283     new_path="$unix_path"
24284   fi
24285 
24286   if test "x$path" != "x$new_path"; then
24287     BOOT_JDK="$new_path"
24288     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24289 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24290   fi
24291 
24292   # Save the first 10 bytes of this path to the storage, so fixpath can work.
24293   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24294 
24295     else
24296       # We're on a unix platform. Hooray! :)
24297       path="$BOOT_JDK"
24298       has_space=`$ECHO "$path" | $GREP " "`
24299       if test "x$has_space" != x; then
24300         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24301 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24302         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24303       fi
24304 
24305       # Use eval to expand a potential ~
24306       eval path="$path"
24307       if test ! -f "$path" && test ! -d "$path"; then
24308         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24309       fi
24310 
24311       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24312     fi
24313   fi
24314 
24315             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24316 $as_echo_n "checking for Boot JDK... " >&6; }
24317             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24318 $as_echo "$BOOT_JDK" >&6; }
24319             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24320 $as_echo_n "checking Boot JDK version... " >&6; }
24321             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
24322             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24323 $as_echo "$BOOT_JDK_VERSION" >&6; }
24324           fi # end check jdk version
24325         fi # end check javac
24326       fi # end check java
24327     fi # end check boot jdk found
24328   fi
24329 
24330 
24331   # Test: Is $JAVA_HOME set?
24332 
24333   if test "x$BOOT_JDK_FOUND" = xno; then
24334     # Now execute the test
24335 
24336   if test "x$JAVA_HOME" != x; then
24337     JAVA_HOME_PROCESSED="$JAVA_HOME"
24338 
24339   # Only process if variable expands to non-empty
24340 
24341   if test "x$JAVA_HOME_PROCESSED" != x; then
24342     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24343 
24344   # Input might be given as Windows format, start by converting to
24345   # unix format.
24346   path="$JAVA_HOME_PROCESSED"
24347   new_path=`$CYGPATH -u "$path"`
24348 
24349   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24350   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24351   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24352   # "foo.exe" is OK but "foo" is an error.
24353   #
24354   # This test is therefore slightly more accurate than "test -f" to check for file precense.
24355   # It is also a way to make sure we got the proper file name for the real test later on.
24356   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24357   if test "x$test_shortpath" = x; then
24358     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&5
24359 $as_echo "$as_me: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&6;}
24360     as_fn_error $? "Cannot locate the the path of JAVA_HOME_PROCESSED" "$LINENO" 5
24361   fi
24362 
24363   # Call helper function which possibly converts this using DOS-style short mode.
24364   # If so, the updated path is stored in $new_path.
24365 
24366   input_path="$new_path"
24367   # Check if we need to convert this using DOS-style short mode. If the path
24368   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24369   # take no chances and rewrite it.
24370   # Note: m4 eats our [], so we need to use [ and ] instead.
24371   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24372   if test "x$has_forbidden_chars" != x; then
24373     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24374     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24375     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24376     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24377       # Going to short mode and back again did indeed matter. Since short mode is
24378       # case insensitive, let's make it lowercase to improve readability.
24379       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24380       # Now convert it back to Unix-style (cygpath)
24381       input_path=`$CYGPATH -u "$shortmode_path"`
24382       new_path="$input_path"
24383     fi
24384   fi
24385 
24386   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24387   if test "x$test_cygdrive_prefix" = x; then
24388     # As a simple fix, exclude /usr/bin since it's not a real path.
24389     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24390       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24391       # a path prefixed by /cygdrive for fixpath to work.
24392       new_path="$CYGWIN_ROOT_PATH$input_path"
24393     fi
24394   fi
24395 
24396 
24397   if test "x$path" != "x$new_path"; then
24398     JAVA_HOME_PROCESSED="$new_path"
24399     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&5
24400 $as_echo "$as_me: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&6;}
24401   fi
24402 
24403     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24404 
24405   path="$JAVA_HOME_PROCESSED"
24406   has_colon=`$ECHO $path | $GREP ^.:`
24407   new_path="$path"
24408   if test "x$has_colon" = x; then
24409     # Not in mixed or Windows style, start by that.
24410     new_path=`cmd //c echo $path`
24411   fi
24412 
24413 
24414   input_path="$new_path"
24415   # Check if we need to convert this using DOS-style short mode. If the path
24416   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24417   # take no chances and rewrite it.
24418   # Note: m4 eats our [], so we need to use [ and ] instead.
24419   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24420   if test "x$has_forbidden_chars" != x; then
24421     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24422     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24423   fi
24424 
24425 
24426   windows_path="$new_path"
24427   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24428     unix_path=`$CYGPATH -u "$windows_path"`
24429     new_path="$unix_path"
24430   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24431     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24432     new_path="$unix_path"
24433   fi
24434 
24435   if test "x$path" != "x$new_path"; then
24436     JAVA_HOME_PROCESSED="$new_path"
24437     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&5
24438 $as_echo "$as_me: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&6;}
24439   fi
24440 
24441   # Save the first 10 bytes of this path to the storage, so fixpath can work.
24442   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24443 
24444     else
24445       # We're on a unix platform. Hooray! :)
24446       path="$JAVA_HOME_PROCESSED"
24447       has_space=`$ECHO "$path" | $GREP " "`
24448       if test "x$has_space" != x; then
24449         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&5
24450 $as_echo "$as_me: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&6;}
24451         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24452       fi
24453 
24454       # Use eval to expand a potential ~
24455       eval path="$path"
24456       if test ! -f "$path" && test ! -d "$path"; then
24457         as_fn_error $? "The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is not found." "$LINENO" 5
24458       fi
24459 
24460       JAVA_HOME_PROCESSED="`cd "$path"; $THEPWDCMD -L`"
24461     fi
24462   fi
24463 
24464     if test ! -d "$JAVA_HOME_PROCESSED"; then
24465       { $as_echo "$as_me:${as_lineno-$LINENO}: Your JAVA_HOME points to a non-existing directory!" >&5
24466 $as_echo "$as_me: Your JAVA_HOME points to a non-existing directory!" >&6;}
24467     else
24468       # Aha, the user has set a JAVA_HOME
24469       # let us use that as the Boot JDK.
24470       BOOT_JDK="$JAVA_HOME_PROCESSED"
24471       BOOT_JDK_FOUND=maybe
24472       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using JAVA_HOME" >&5
24473 $as_echo "$as_me: Found potential Boot JDK using JAVA_HOME" >&6;}
24474     fi
24475   fi
24476 
24477 
24478     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24479     if test "x$BOOT_JDK_FOUND" = xmaybe; then
24480       # Do we have a bin/java?
24481       if test ! -x "$BOOT_JDK/bin/java"; then
24482         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24483 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24484         BOOT_JDK_FOUND=no
24485       else
24486         # Do we have a bin/javac?
24487         if test ! -x "$BOOT_JDK/bin/javac"; then
24488           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24489 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24490           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24491 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24492           BOOT_JDK_FOUND=no
24493         else
24494           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24495           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24496 
24497           # Extra M4 quote needed to protect [] in grep expression.
24498           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
24499           if test "x$FOUND_CORRECT_VERSION" = x; then
24500             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24501 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24502             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
24503 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
24504             BOOT_JDK_FOUND=no
24505           else
24506             # We're done! :-)
24507             BOOT_JDK_FOUND=yes
24508 
24509   # Only process if variable expands to non-empty
24510 
24511   if test "x$BOOT_JDK" != x; then
24512     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24513 
24514   # Input might be given as Windows format, start by converting to
24515   # unix format.
24516   path="$BOOT_JDK"
24517   new_path=`$CYGPATH -u "$path"`
24518 
24519   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24520   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24521   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24522   # "foo.exe" is OK but "foo" is an error.
24523   #
24524   # This test is therefore slightly more accurate than "test -f" to check for file precense.
24525   # It is also a way to make sure we got the proper file name for the real test later on.
24526   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24527   if test "x$test_shortpath" = x; then
24528     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24529 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24530     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24531   fi
24532 
24533   # Call helper function which possibly converts this using DOS-style short mode.
24534   # If so, the updated path is stored in $new_path.
24535 
24536   input_path="$new_path"
24537   # Check if we need to convert this using DOS-style short mode. If the path
24538   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24539   # take no chances and rewrite it.
24540   # Note: m4 eats our [], so we need to use [ and ] instead.
24541   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24542   if test "x$has_forbidden_chars" != x; then
24543     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24544     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24545     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24546     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24547       # Going to short mode and back again did indeed matter. Since short mode is
24548       # case insensitive, let's make it lowercase to improve readability.
24549       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24550       # Now convert it back to Unix-style (cygpath)
24551       input_path=`$CYGPATH -u "$shortmode_path"`
24552       new_path="$input_path"
24553     fi
24554   fi
24555 
24556   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24557   if test "x$test_cygdrive_prefix" = x; then
24558     # As a simple fix, exclude /usr/bin since it's not a real path.
24559     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24560       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24561       # a path prefixed by /cygdrive for fixpath to work.
24562       new_path="$CYGWIN_ROOT_PATH$input_path"
24563     fi
24564   fi
24565 
24566 
24567   if test "x$path" != "x$new_path"; then
24568     BOOT_JDK="$new_path"
24569     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24570 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24571   fi
24572 
24573     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24574 
24575   path="$BOOT_JDK"
24576   has_colon=`$ECHO $path | $GREP ^.:`
24577   new_path="$path"
24578   if test "x$has_colon" = x; then
24579     # Not in mixed or Windows style, start by that.
24580     new_path=`cmd //c echo $path`
24581   fi
24582 
24583 
24584   input_path="$new_path"
24585   # Check if we need to convert this using DOS-style short mode. If the path
24586   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24587   # take no chances and rewrite it.
24588   # Note: m4 eats our [], so we need to use [ and ] instead.
24589   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24590   if test "x$has_forbidden_chars" != x; then
24591     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24592     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24593   fi
24594 
24595 
24596   windows_path="$new_path"
24597   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24598     unix_path=`$CYGPATH -u "$windows_path"`
24599     new_path="$unix_path"
24600   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24601     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24602     new_path="$unix_path"
24603   fi
24604 
24605   if test "x$path" != "x$new_path"; then
24606     BOOT_JDK="$new_path"
24607     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24608 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24609   fi
24610 
24611   # Save the first 10 bytes of this path to the storage, so fixpath can work.
24612   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24613 
24614     else
24615       # We're on a unix platform. Hooray! :)
24616       path="$BOOT_JDK"
24617       has_space=`$ECHO "$path" | $GREP " "`
24618       if test "x$has_space" != x; then
24619         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24620 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24621         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24622       fi
24623 
24624       # Use eval to expand a potential ~
24625       eval path="$path"
24626       if test ! -f "$path" && test ! -d "$path"; then
24627         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24628       fi
24629 
24630       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24631     fi
24632   fi
24633 
24634             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24635 $as_echo_n "checking for Boot JDK... " >&6; }
24636             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24637 $as_echo "$BOOT_JDK" >&6; }
24638             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24639 $as_echo_n "checking Boot JDK version... " >&6; }
24640             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
24641             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24642 $as_echo "$BOOT_JDK_VERSION" >&6; }
24643           fi # end check jdk version
24644         fi # end check javac
24645       fi # end check java
24646     fi # end check boot jdk found
24647   fi
24648 
24649 
24650   # Test: Is there a java or javac in the PATH, which is a symlink to the JDK?
24651 
24652   if test "x$BOOT_JDK_FOUND" = xno; then
24653     # Now execute the test
24654 
24655   # Extract the first word of "javac", so it can be a program name with args.
24656 set dummy javac; ac_word=$2
24657 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
24658 $as_echo_n "checking for $ac_word... " >&6; }
24659 if ${ac_cv_path_JAVAC_CHECK+:} false; then :
24660   $as_echo_n "(cached) " >&6
24661 else
24662   case $JAVAC_CHECK in
24663   [\\/]* | ?:[\\/]*)
24664   ac_cv_path_JAVAC_CHECK="$JAVAC_CHECK" # Let the user override the test with a path.
24665   ;;
24666   *)
24667   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
24668 for as_dir in $PATH
24669 do
24670   IFS=$as_save_IFS
24671   test -z "$as_dir" && as_dir=.
24672     for ac_exec_ext in '' $ac_executable_extensions; do
24673   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
24674     ac_cv_path_JAVAC_CHECK="$as_dir/$ac_word$ac_exec_ext"
24675     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
24676     break 2
24677   fi
24678 done
24679   done
24680 IFS=$as_save_IFS
24681 
24682   ;;
24683 esac
24684 fi
24685 JAVAC_CHECK=$ac_cv_path_JAVAC_CHECK
24686 if test -n "$JAVAC_CHECK"; then
24687   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAVAC_CHECK" >&5
24688 $as_echo "$JAVAC_CHECK" >&6; }
24689 else
24690   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
24691 $as_echo "no" >&6; }
24692 fi
24693 
24694 
24695   # Extract the first word of "java", so it can be a program name with args.
24696 set dummy java; ac_word=$2
24697 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
24698 $as_echo_n "checking for $ac_word... " >&6; }
24699 if ${ac_cv_path_JAVA_CHECK+:} false; then :
24700   $as_echo_n "(cached) " >&6
24701 else
24702   case $JAVA_CHECK in
24703   [\\/]* | ?:[\\/]*)
24704   ac_cv_path_JAVA_CHECK="$JAVA_CHECK" # Let the user override the test with a path.
24705   ;;
24706   *)
24707   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
24708 for as_dir in $PATH
24709 do
24710   IFS=$as_save_IFS
24711   test -z "$as_dir" && as_dir=.
24712     for ac_exec_ext in '' $ac_executable_extensions; do
24713   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
24714     ac_cv_path_JAVA_CHECK="$as_dir/$ac_word$ac_exec_ext"
24715     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
24716     break 2
24717   fi
24718 done
24719   done
24720 IFS=$as_save_IFS
24721 
24722   ;;
24723 esac
24724 fi
24725 JAVA_CHECK=$ac_cv_path_JAVA_CHECK
24726 if test -n "$JAVA_CHECK"; then
24727   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAVA_CHECK" >&5
24728 $as_echo "$JAVA_CHECK" >&6; }
24729 else
24730   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
24731 $as_echo "no" >&6; }
24732 fi
24733 
24734 
24735   BINARY="$JAVAC_CHECK"
24736   if test "x$JAVAC_CHECK" = x; then
24737     BINARY="$JAVA_CHECK"
24738   fi
24739   if test "x$BINARY" != x; then
24740     # So there is a java(c) binary, it might be part of a JDK.
24741     # Lets find the JDK/JRE directory by following symbolic links.
24742     # Linux/GNU systems often have links from /usr/bin/java to
24743     # /etc/alternatives/java to the real JDK binary.
24744 
24745   if test "x$OPENJDK_BUILD_OS" != xwindows; then
24746     # Follow a chain of symbolic links. Use readlink
24747     # where it exists, else fall back to horribly
24748     # complicated shell code.
24749     if test "x$READLINK_TESTED" != yes; then
24750       # On MacOSX there is a readlink tool with a different
24751       # purpose than the GNU readlink tool. Check the found readlink.
24752       ISGNU=`$READLINK --version 2>&1 | $GREP GNU`
24753       if test "x$ISGNU" = x; then
24754         # A readlink that we do not know how to use.
24755         # Are there other non-GNU readlinks out there?
24756         READLINK_TESTED=yes
24757         READLINK=
24758       fi
24759     fi
24760 
24761     if test "x$READLINK" != x; then
24762       BINARY=`$READLINK -f $BINARY`
24763     else
24764       # Save the current directory for restoring afterwards
24765       STARTDIR=$PWD
24766       COUNTER=0
24767       sym_link_dir=`$DIRNAME $BINARY`
24768       sym_link_file=`$BASENAME $BINARY`
24769       cd $sym_link_dir
24770       # Use -P flag to resolve symlinks in directories.
24771       cd `$THEPWDCMD -P`
24772       sym_link_dir=`$THEPWDCMD -P`
24773       # Resolve file symlinks
24774       while test $COUNTER -lt 20; do
24775         ISLINK=`$LS -l $sym_link_dir/$sym_link_file | $GREP '\->' | $SED -e 's/.*-> \(.*\)/\1/'`
24776         if test "x$ISLINK" == x; then
24777           # This is not a symbolic link! We are done!
24778           break
24779         fi
24780         # Again resolve directory symlinks since the target of the just found
24781         # link could be in a different directory
24782         cd `$DIRNAME $ISLINK`
24783         sym_link_dir=`$THEPWDCMD -P`
24784         sym_link_file=`$BASENAME $ISLINK`
24785         let COUNTER=COUNTER+1
24786       done
24787       cd $STARTDIR
24788       BINARY=$sym_link_dir/$sym_link_file
24789     fi
24790   fi
24791 
24792     BOOT_JDK=`dirname "$BINARY"`
24793     BOOT_JDK=`cd "$BOOT_JDK/.."; pwd`
24794     if test -x "$BOOT_JDK/bin/javac" && test -x "$BOOT_JDK/bin/java"; then
24795       # Looks like we found ourselves an JDK
24796       BOOT_JDK_FOUND=maybe
24797       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using java(c) in PATH" >&5
24798 $as_echo "$as_me: Found potential Boot JDK using java(c) in PATH" >&6;}
24799     fi
24800   fi
24801 
24802 
24803     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24804     if test "x$BOOT_JDK_FOUND" = xmaybe; then
24805       # Do we have a bin/java?
24806       if test ! -x "$BOOT_JDK/bin/java"; then
24807         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24808 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24809         BOOT_JDK_FOUND=no
24810       else
24811         # Do we have a bin/javac?
24812         if test ! -x "$BOOT_JDK/bin/javac"; then
24813           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24814 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24815           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24816 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24817           BOOT_JDK_FOUND=no
24818         else
24819           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24820           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24821 
24822           # Extra M4 quote needed to protect [] in grep expression.
24823           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
24824           if test "x$FOUND_CORRECT_VERSION" = x; then
24825             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24826 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24827             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
24828 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
24829             BOOT_JDK_FOUND=no
24830           else
24831             # We're done! :-)
24832             BOOT_JDK_FOUND=yes
24833 
24834   # Only process if variable expands to non-empty
24835 
24836   if test "x$BOOT_JDK" != x; then
24837     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24838 
24839   # Input might be given as Windows format, start by converting to
24840   # unix format.
24841   path="$BOOT_JDK"
24842   new_path=`$CYGPATH -u "$path"`
24843 
24844   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24845   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24846   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24847   # "foo.exe" is OK but "foo" is an error.
24848   #
24849   # This test is therefore slightly more accurate than "test -f" to check for file precense.
24850   # It is also a way to make sure we got the proper file name for the real test later on.
24851   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24852   if test "x$test_shortpath" = x; then
24853     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24854 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24855     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24856   fi
24857 
24858   # Call helper function which possibly converts this using DOS-style short mode.
24859   # If so, the updated path is stored in $new_path.
24860 
24861   input_path="$new_path"
24862   # Check if we need to convert this using DOS-style short mode. If the path
24863   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24864   # take no chances and rewrite it.
24865   # Note: m4 eats our [], so we need to use [ and ] instead.
24866   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24867   if test "x$has_forbidden_chars" != x; then
24868     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24869     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24870     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24871     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24872       # Going to short mode and back again did indeed matter. Since short mode is
24873       # case insensitive, let's make it lowercase to improve readability.
24874       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24875       # Now convert it back to Unix-style (cygpath)
24876       input_path=`$CYGPATH -u "$shortmode_path"`
24877       new_path="$input_path"
24878     fi
24879   fi
24880 
24881   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24882   if test "x$test_cygdrive_prefix" = x; then
24883     # As a simple fix, exclude /usr/bin since it's not a real path.
24884     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24885       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24886       # a path prefixed by /cygdrive for fixpath to work.
24887       new_path="$CYGWIN_ROOT_PATH$input_path"
24888     fi
24889   fi
24890 
24891 
24892   if test "x$path" != "x$new_path"; then
24893     BOOT_JDK="$new_path"
24894     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24895 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24896   fi
24897 
24898     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24899 
24900   path="$BOOT_JDK"
24901   has_colon=`$ECHO $path | $GREP ^.:`
24902   new_path="$path"
24903   if test "x$has_colon" = x; then
24904     # Not in mixed or Windows style, start by that.
24905     new_path=`cmd //c echo $path`
24906   fi
24907 
24908 
24909   input_path="$new_path"
24910   # Check if we need to convert this using DOS-style short mode. If the path
24911   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24912   # take no chances and rewrite it.
24913   # Note: m4 eats our [], so we need to use [ and ] instead.
24914   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24915   if test "x$has_forbidden_chars" != x; then
24916     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24917     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24918   fi
24919 
24920 
24921   windows_path="$new_path"
24922   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24923     unix_path=`$CYGPATH -u "$windows_path"`
24924     new_path="$unix_path"
24925   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24926     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24927     new_path="$unix_path"
24928   fi
24929 
24930   if test "x$path" != "x$new_path"; then
24931     BOOT_JDK="$new_path"
24932     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24933 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24934   fi
24935 
24936   # Save the first 10 bytes of this path to the storage, so fixpath can work.
24937   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24938 
24939     else
24940       # We're on a unix platform. Hooray! :)
24941       path="$BOOT_JDK"
24942       has_space=`$ECHO "$path" | $GREP " "`
24943       if test "x$has_space" != x; then
24944         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24945 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24946         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24947       fi
24948 
24949       # Use eval to expand a potential ~
24950       eval path="$path"
24951       if test ! -f "$path" && test ! -d "$path"; then
24952         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24953       fi
24954 
24955       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24956     fi
24957   fi
24958 
24959             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24960 $as_echo_n "checking for Boot JDK... " >&6; }
24961             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24962 $as_echo "$BOOT_JDK" >&6; }
24963             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24964 $as_echo_n "checking Boot JDK version... " >&6; }
24965             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
24966             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24967 $as_echo "$BOOT_JDK_VERSION" >&6; }
24968           fi # end check jdk version
24969         fi # end check javac
24970       fi # end check java
24971     fi # end check boot jdk found
24972   fi
24973 
24974 
24975   # Test: Is there a JDK installed in default, well-known locations?
24976 
24977   if test "x$BOOT_JDK_FOUND" = xno; then
24978     # Now execute the test
24979 
24980   if test "x$OPENJDK_TARGET_OS" = xwindows; then
24981 
24982   if test "x$BOOT_JDK_FOUND" = xno; then
24983     # Now execute the test
24984 
24985   if test "x$ProgramW6432" != x; then
24986     VIRTUAL_DIR="$ProgramW6432/Java"
24987 
24988   windows_path="$VIRTUAL_DIR"
24989   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24990     unix_path=`$CYGPATH -u "$windows_path"`
24991     VIRTUAL_DIR="$unix_path"
24992   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24993     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24994     VIRTUAL_DIR="$unix_path"
24995   fi
24996 
24997 
24998   BOOT_JDK_PREFIX="$VIRTUAL_DIR"
24999   BOOT_JDK_SUFFIX=""
25000   ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
25001   if test "x$ALL_JDKS_FOUND" != x; then
25002     for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
25003 
25004   if test "x$BOOT_JDK_FOUND" = xno; then
25005     # Now execute the test
25006 
25007         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
25008         if test -d "$BOOT_JDK"; then
25009           BOOT_JDK_FOUND=maybe
25010           { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
25011 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
25012         fi
25013 
25014 
25015     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
25016     if test "x$BOOT_JDK_FOUND" = xmaybe; then
25017       # Do we have a bin/java?
25018       if test ! -x "$BOOT_JDK/bin/java"; then
25019         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
25020 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
25021         BOOT_JDK_FOUND=no
25022       else
25023         # Do we have a bin/javac?
25024         if test ! -x "$BOOT_JDK/bin/javac"; then
25025           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
25026 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
25027           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
25028 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
25029           BOOT_JDK_FOUND=no
25030         else
25031           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
25032           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
25033 
25034           # Extra M4 quote needed to protect [] in grep expression.
25035           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
25036           if test "x$FOUND_CORRECT_VERSION" = x; then
25037             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
25038 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
25039             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
25040 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
25041             BOOT_JDK_FOUND=no
25042           else
25043             # We're done! :-)
25044             BOOT_JDK_FOUND=yes
25045 
25046   # Only process if variable expands to non-empty
25047 
25048   if test "x$BOOT_JDK" != x; then
25049     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
25050 
25051   # Input might be given as Windows format, start by converting to
25052   # unix format.
25053   path="$BOOT_JDK"
25054   new_path=`$CYGPATH -u "$path"`
25055 
25056   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
25057   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
25058   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
25059   # "foo.exe" is OK but "foo" is an error.
25060   #
25061   # This test is therefore slightly more accurate than "test -f" to check for file precense.
25062   # It is also a way to make sure we got the proper file name for the real test later on.
25063   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
25064   if test "x$test_shortpath" = x; then
25065     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
25066 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
25067     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
25068   fi
25069 
25070   # Call helper function which possibly converts this using DOS-style short mode.
25071   # If so, the updated path is stored in $new_path.
25072 
25073   input_path="$new_path"
25074   # Check if we need to convert this using DOS-style short mode. If the path
25075   # contains just simple characters, use it. Otherwise (spaces, weird characters),
25076   # take no chances and rewrite it.
25077   # Note: m4 eats our [], so we need to use [ and ] instead.
25078   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
25079   if test "x$has_forbidden_chars" != x; then
25080     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
25081     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
25082     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
25083     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
25084       # Going to short mode and back again did indeed matter. Since short mode is
25085       # case insensitive, let's make it lowercase to improve readability.
25086       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
25087       # Now convert it back t