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 BOOTCYCLE_JVM_ARGS_BIG
 648 JAVA_FLAGS_BIG
 649 JAVA_FLAGS
 650 TEST_JOBS
 651 JOBS
 652 MEMORY_SIZE
 653 NUM_CORES
 654 ENABLE_GENERATE_CLASSLIST
 655 BUILD_FAILURE_HANDLER
 656 ENABLE_INTREE_EC
 657 STLPORT_LIB
 658 LIBZIP_CAN_USE_MMAP
 659 LIBDL
 660 LIBM
 661 USE_EXTERNAL_LCMS
 662 LCMS_LIBS
 663 LCMS_CFLAGS
 664 USE_EXTERNAL_LIBZ
 665 USE_EXTERNAL_LIBPNG
 666 PNG_LIBS
 667 PNG_CFLAGS
 668 USE_EXTERNAL_LIBGIF
 669 USE_EXTERNAL_LIBJPEG
 670 LLVM_LIBS
 671 LLVM_LDFLAGS
 672 LLVM_CFLAGS
 673 LLVM_CONFIG
 674 LIBFFI_LIBS
 675 LIBFFI_CFLAGS
 676 ALSA_LIBS
 677 ALSA_CFLAGS
 678 FREETYPE_BUNDLE_LIB_PATH
 679 FREETYPE_LIBS
 680 FREETYPE_CFLAGS
 681 CUPS_CFLAGS
 682 X_EXTRA_LIBS
 683 X_LIBS
 684 X_PRE_LIBS
 685 X_CFLAGS
 686 XMKMF
 687 MSVCP_DLL
 688 MSVCR_DLL
 689 LIBCXX
 690 STATIC_CXX_SETTING
 691 FIXPATH_DETACH_FLAG
 692 FIXPATH
 693 BUILD_GTEST
 694 VALID_JVM_FEATURES
 695 JVM_FEATURES_custom
 696 JVM_FEATURES_zeroshark
 697 JVM_FEATURES_zero
 698 JVM_FEATURES_minimal
 699 JVM_FEATURES_core
 700 JVM_FEATURES_client
 701 JVM_FEATURES_server
 702 INCLUDE_DTRACE
 703 GCOV_ENABLED
 704 STRIP_POLICY
 705 DEBUG_BINARIES
 706 ZIP_EXTERNAL_DEBUG_SYMBOLS
 707 COPY_DEBUG_SYMBOLS
 708 COMPILE_WITH_DEBUG_SYMBOLS
 709 CFLAGS_WARNINGS_ARE_ERRORS
 710 BUILD_CC_DISABLE_WARNING_PREFIX
 711 DISABLE_WARNING_PREFIX
 712 HOTSPOT_SET_WARNINGS_AS_ERRORS
 713 WARNINGS_AS_ERRORS
 714 COMPILER_SUPPORTS_TARGET_BITS_FLAG
 715 ZERO_ARCHFLAG
 716 LDFLAGS_TESTEXE
 717 LDFLAGS_TESTLIB
 718 CXXFLAGS_TESTEXE
 719 CXXFLAGS_TESTLIB
 720 CFLAGS_TESTEXE
 721 CFLAGS_TESTLIB
 722 OPENJDK_BUILD_JVM_LIBS
 723 OPENJDK_BUILD_JVM_ASFLAGS
 724 OPENJDK_BUILD_JVM_LDFLAGS
 725 OPENJDK_BUILD_JVM_CFLAGS
 726 OPENJDK_BUILD_LDFLAGS_HASH_STYLE
 727 OPENJDK_BUILD_LDFLAGS_CXX_JDK
 728 OPENJDK_BUILD_JDKEXE_LIBS
 729 OPENJDK_BUILD_JDKLIB_LIBS
 730 OPENJDK_BUILD_LDFLAGS_JDKEXE
 731 OPENJDK_BUILD_LDFLAGS_JDKLIB
 732 OPENJDK_BUILD_CXXFLAGS_JDKEXE
 733 OPENJDK_BUILD_CXXFLAGS_JDKLIB
 734 OPENJDK_BUILD_CFLAGS_JDKEXE
 735 OPENJDK_BUILD_CFLAGS_JDKLIB
 736 OPENJDK_BUILD_CXXSTD_CXXFLAG
 737 JVM_LIBS
 738 JVM_ASFLAGS
 739 JVM_LDFLAGS
 740 JVM_CFLAGS
 741 LDFLAGS_HASH_STYLE
 742 LDFLAGS_CXX_JDK
 743 JDKEXE_LIBS
 744 JDKLIB_LIBS
 745 LDFLAGS_JDKEXE
 746 LDFLAGS_JDKLIB
 747 CXXFLAGS_JDKEXE
 748 CXXFLAGS_JDKLIB
 749 CFLAGS_JDKEXE
 750 CFLAGS_JDKLIB
 751 MACOSX_VERSION_MIN
 752 CXXSTD_CXXFLAG
 753 CXX_O_FLAG_SIZE
 754 CXX_O_FLAG_NONE
 755 CXX_O_FLAG_DEBUG
 756 CXX_O_FLAG_NORM
 757 CXX_O_FLAG_HI
 758 CXX_O_FLAG_HIGHEST
 759 CXX_O_FLAG_HIGHEST_JVM
 760 C_O_FLAG_SIZE
 761 C_O_FLAG_NONE
 762 C_O_FLAG_DEBUG
 763 C_O_FLAG_NORM
 764 C_O_FLAG_HI
 765 C_O_FLAG_HIGHEST
 766 C_O_FLAG_HIGHEST_JVM
 767 JVM_CFLAGS_SYMBOLS
 768 CXXFLAGS_DEBUG_SYMBOLS
 769 CFLAGS_DEBUG_SYMBOLS
 770 CXX_FLAG_DEPS
 771 C_FLAG_DEPS
 772 SHARED_LIBRARY_FLAGS
 773 SET_SHARED_LIBRARY_MAPFILE
 774 SET_SHARED_LIBRARY_NAME
 775 SET_SHARED_LIBRARY_ORIGIN
 776 SET_EXECUTABLE_ORIGIN
 777 CXX_FLAG_REORDER
 778 C_FLAG_REORDER
 779 JVM_RCFLAGS
 780 RC_FLAGS
 781 AR_OUT_OPTION
 782 LD_OUT_OPTION
 783 EXE_OUT_OPTION
 784 CC_OUT_OPTION
 785 STRIPFLAGS
 786 ARFLAGS
 787 COMPILER_BINDCMD_FILE_FLAG
 788 COMPILER_COMMAND_FILE_FLAG
 789 COMPILER_TARGET_BITS_FLAG
 790 JT_HOME
 791 JTREGEXE
 792 HOTSPOT_TOOLCHAIN_TYPE
 793 USING_BROKEN_SUSE_LD
 794 PACKAGE_PATH
 795 USE_CLANG
 796 HOTSPOT_LD
 797 HOTSPOT_CXX
 798 HOTSPOT_RC
 799 HOTSPOT_MT
 800 BUILD_AS
 801 BUILD_LDCXX
 802 BUILD_LD
 803 BUILD_STRIP
 804 BUILD_OBJCOPY
 805 BUILD_AR
 806 BUILD_NM
 807 BUILD_CXX
 808 BUILD_CC
 809 BUILD_SYSROOT_LDFLAGS
 810 BUILD_SYSROOT_CFLAGS
 811 ac_ct_OBJDUMP
 812 OBJDUMP
 813 ac_ct_OBJCOPY
 814 OBJCOPY
 815 ac_ct_NM
 816 ac_ct_STRIP
 817 GNM
 818 NM
 819 STRIP
 820 MSBUILD
 821 DUMPBIN
 822 RC
 823 MT
 824 LIPO
 825 ac_ct_AR
 826 AR
 827 AS
 828 LDCXX
 829 LD
 830 CXXCPP
 831 CPP
 832 CXX_VERSION_NUMBER
 833 CC_VERSION_NUMBER
 834 ac_ct_CXX
 835 CXXFLAGS
 836 CXX
 837 TOOLCHAIN_PATH_CXX
 838 POTENTIAL_CXX
 839 OBJEXT
 840 EXEEXT
 841 ac_ct_CC
 842 CPPFLAGS
 843 LDFLAGS
 844 CFLAGS
 845 CC
 846 TOOLCHAIN_PATH_CC
 847 POTENTIAL_CC
 848 TOOLCHAIN_VERSION
 849 VS_LIB
 850 VS_INCLUDE
 851 VS_PATH
 852 CYGWIN_LINK
 853 SYSROOT_LDFLAGS
 854 SYSROOT_CFLAGS
 855 EXTRA_LDFLAGS
 856 EXTRA_CXXFLAGS
 857 EXTRA_CFLAGS
 858 LEGACY_EXTRA_LDFLAGS
 859 LEGACY_EXTRA_CXXFLAGS
 860 LEGACY_EXTRA_CFLAGS
 861 EXE_SUFFIX
 862 OBJ_SUFFIX
 863 STATIC_LIBRARY
 864 SHARED_LIBRARY
 865 STATIC_LIBRARY_SUFFIX
 866 SHARED_LIBRARY_SUFFIX
 867 LIBRARY_PREFIX
 868 TOOLCHAIN_TYPE
 869 STATIC_BUILD
 870 IMPORT_MODULES_MAKE
 871 IMPORT_MODULES_SRC
 872 IMPORT_MODULES_CONF
 873 IMPORT_MODULES_LIBS
 874 IMPORT_MODULES_CMDS
 875 IMPORT_MODULES_CLASSES
 876 BUILD_HOTSPOT
 877 HOTSPOT_DIST
 878 BUILD_OUTPUT
 879 JDK_TOPDIR
 880 NASHORN_TOPDIR
 881 HOTSPOT_TOPDIR
 882 JAXWS_TOPDIR
 883 JAXP_TOPDIR
 884 CORBA_TOPDIR
 885 LANGTOOLS_TOPDIR
 886 EXTERNAL_BUILDJDK
 887 BUILD_JDK
 888 CREATE_BUILDJDK
 889 JLINK
 890 JMOD
 891 BOOT_JDK_BITS
 892 JAVAC_FLAGS
 893 BOOT_JDK_MODULAR
 894 BOOT_JDK_SOURCETARGET
 895 JARSIGNER
 896 JAR
 897 JAVAH
 898 JAVAC
 899 JAVA
 900 BOOT_JDK
 901 JAVA_CHECK
 902 JAVAC_CHECK
 903 VERSION_IS_GA
 904 VERSION_SHORT
 905 VERSION_STRING
 906 VERSION_NUMBER_FOUR_POSITIONS
 907 VERSION_NUMBER
 908 VERSION_OPT
 909 VERSION_BUILD
 910 VERSION_PRE
 911 VERSION_PATCH
 912 VERSION_SECURITY
 913 VERSION_MINOR
 914 VERSION_MAJOR
 915 MACOSX_BUNDLE_ID_BASE
 916 MACOSX_BUNDLE_NAME_BASE
 917 HOTSPOT_VM_DISTRO
 918 COMPANY_NAME
 919 JDK_RC_PLATFORM_NAME
 920 PRODUCT_SUFFIX
 921 PRODUCT_NAME
 922 LAUNCHER_NAME
 923 JLINK_KEEP_PACKAGED_MODULES
 924 COPYRIGHT_YEAR
 925 COMPRESS_JARS
 926 INCLUDE_SA
 927 UNLIMITED_CRYPTO
 928 CACERTS_FILE
 929 BUILD_HEADLESS
 930 SUPPORT_HEADFUL
 931 SUPPORT_HEADLESS
 932 DEFAULT_MAKE_TARGET
 933 OS_VERSION_MICRO
 934 OS_VERSION_MINOR
 935 OS_VERSION_MAJOR
 936 PKG_CONFIG
 937 BASH_ARGS
 938 SETFILE
 939 CODESIGN
 940 XATTR
 941 DSYMUTIL
 942 IS_GNU_TIME
 943 PATCH
 944 DTRACE
 945 TIME
 946 STAT
 947 HG
 948 READELF
 949 OTOOL
 950 LDD
 951 ZIP
 952 UNZIP
 953 TAR_SUPPORTS_TRANSFORM
 954 TAR_INCLUDE_PARAM
 955 TAR_CREATE_EXTRA_PARAM
 956 TAR_TYPE
 957 FIND_DELETE
 958 OUTPUT_SYNC
 959 OUTPUT_SYNC_SUPPORTED
 960 CHECK_TOOLSDIR_MAKE
 961 CHECK_TOOLSDIR_GMAKE
 962 CHECK_MAKE
 963 CHECK_GMAKE
 964 MAKE
 965 PKGHANDLER
 966 CONFIGURESUPPORT_OUTPUTDIR
 967 OUTPUT_ROOT
 968 CONF_NAME
 969 SPEC
 970 SDKROOT
 971 XCODEBUILD
 972 VALID_JVM_VARIANTS
 973 JVM_VARIANTS
 974 DEBUG_LEVEL
 975 HOTSPOT_DEBUG_LEVEL
 976 JDK_VARIANT
 977 USERNAME
 978 CANONICAL_TOPDIR
 979 ORIGINAL_TOPDIR
 980 TOPDIR
 981 PATH_SEP
 982 ZERO_ARCHDEF
 983 HOTSPOT_BUILD_CPU_DEFINE
 984 HOTSPOT_BUILD_CPU_ARCH
 985 HOTSPOT_BUILD_CPU
 986 HOTSPOT_BUILD_OS_TYPE
 987 HOTSPOT_BUILD_OS
 988 OPENJDK_BUILD_BUNDLE_PLATFORM
 989 OPENJDK_BUILD_CPU_BUNDLE
 990 OPENJDK_BUILD_OS_BUNDLE
 991 OPENJDK_BUILD_OS_EXPORT_DIR
 992 OPENJDK_BUILD_CPU_JLI_CFLAGS
 993 OPENJDK_BUILD_CPU_OSARCH
 994 OPENJDK_BUILD_CPU_ISADIR
 995 OPENJDK_BUILD_CPU_LIBDIR
 996 OPENJDK_BUILD_CPU_LEGACY_LIB
 997 OPENJDK_BUILD_CPU_LEGACY
 998 HOTSPOT_TARGET_CPU_DEFINE
 999 HOTSPOT_TARGET_CPU_ARCH
1000 HOTSPOT_TARGET_CPU
1001 HOTSPOT_TARGET_OS_TYPE
1002 HOTSPOT_TARGET_OS
1003 DEFINE_CROSS_COMPILE_ARCH
1004 LP64
1005 OPENJDK_TARGET_BUNDLE_PLATFORM
1006 OPENJDK_TARGET_CPU_BUNDLE
1007 OPENJDK_TARGET_OS_BUNDLE
1008 OPENJDK_TARGET_OS_EXPORT_DIR
1009 OPENJDK_TARGET_CPU_JLI_CFLAGS
1010 OPENJDK_TARGET_CPU_OSARCH
1011 OPENJDK_TARGET_CPU_ISADIR
1012 OPENJDK_TARGET_CPU_LIBDIR
1013 OPENJDK_TARGET_CPU_LEGACY_LIB
1014 OPENJDK_TARGET_CPU_LEGACY
1015 REQUIRED_OS_VERSION
1016 REQUIRED_OS_NAME
1017 COMPILE_TYPE
1018 OPENJDK_TARGET_CPU_ENDIAN
1019 OPENJDK_TARGET_CPU_BITS
1020 OPENJDK_TARGET_CPU_ARCH
1021 OPENJDK_TARGET_CPU
1022 OPENJDK_TARGET_OS_ENV
1023 OPENJDK_TARGET_OS_TYPE
1024 OPENJDK_TARGET_OS
1025 OPENJDK_BUILD_CPU_ENDIAN
1026 OPENJDK_BUILD_CPU_BITS
1027 OPENJDK_BUILD_CPU_ARCH
1028 OPENJDK_BUILD_CPU
1029 OPENJDK_BUILD_OS_ENV
1030 OPENJDK_BUILD_OS_TYPE
1031 OPENJDK_BUILD_OS
1032 OPENJDK_BUILD_AUTOCONF_NAME
1033 OPENJDK_TARGET_AUTOCONF_NAME
1034 target_os
1035 target_vendor
1036 target_cpu
1037 target
1038 host_os
1039 host_vendor
1040 host_cpu
1041 host
1042 build_os
1043 build_vendor
1044 build_cpu
1045 build
1046 NICE
1047 CPIO
1048 DF
1049 READLINK
1050 CYGPATH
1051 SED
1052 FGREP
1053 EGREP
1054 GREP
1055 AWK
1056 XARGS
1057 WHICH
1058 WC
1059 UNIQ
1060 UNAME
1061 TR
1062 TOUCH
1063 TEE
1064 TAR
1065 TAIL
1066 SORT
1067 SH
1068 RMDIR
1069 RM
1070 PRINTF
1071 NAWK
1072 MV
1073 MKTEMP
1074 MKDIR
1075 LS
1076 LN
1077 GZIP
1078 GUNZIP
1079 HEAD
1080 FIND
1081 FILE
1082 EXPR
1083 ECHO
1084 DIRNAME
1085 DIFF
1086 DATE
1087 CUT
1088 CP
1089 COMM
1090 CMP
1091 CHMOD
1092 CAT
1093 BASH
1094 BASENAME
1095 DATE_WHEN_CONFIGURED
1096 ORIGINAL_PATH
1097 CONFIGURE_COMMAND_LINE
1098 target_alias
1099 host_alias
1100 build_alias
1101 LIBS
1102 ECHO_T
1103 ECHO_N
1104 ECHO_C
1105 DEFS
1106 mandir
1107 localedir
1108 libdir
1109 psdir
1110 pdfdir
1111 dvidir
1112 htmldir
1113 infodir
1114 docdir
1115 oldincludedir
1116 includedir
1117 localstatedir
1118 sharedstatedir
1119 sysconfdir
1120 datadir
1121 datarootdir
1122 libexecdir
1123 sbindir
1124 bindir
1125 program_transform_name
1126 prefix
1127 exec_prefix
1128 PACKAGE_URL
1129 PACKAGE_BUGREPORT
1130 PACKAGE_STRING
1131 PACKAGE_VERSION
1132 PACKAGE_TARNAME
1133 PACKAGE_NAME
1134 PATH_SEPARATOR
1135 SHELL'
1136 ac_subst_files=''
1137 ac_user_opts='
1138 enable_option_checking
1139 with_target_bits
1140 enable_openjdk_only
1141 with_custom_make_dir
1142 with_jdk_variant
1143 enable_debug
1144 with_debug_level
1145 with_jvm_variants
1146 with_devkit
1147 with_sys_root
1148 with_sysroot
1149 with_tools_dir
1150 with_toolchain_path
1151 with_extra_path
1152 with_sdk_name
1153 with_conf_name
1154 with_output_sync
1155 with_default_make_target
1156 enable_headful
1157 with_cacerts_file
1158 enable_unlimited_crypto
1159 with_copyright_year
1160 enable_keep_packaged_modules
1161 with_milestone
1162 with_update_version
1163 with_user_release_suffix
1164 with_build_number
1165 with_version_string
1166 with_version_pre
1167 with_version_opt
1168 with_version_build
1169 with_version_major
1170 with_version_minor
1171 with_version_security
1172 with_version_patch
1173 with_boot_jdk
1174 with_build_jdk
1175 with_add_source_root
1176 with_override_source_root
1177 with_adds_and_overrides
1178 with_override_langtools
1179 with_override_corba
1180 with_override_jaxp
1181 with_override_jaxws
1182 with_override_hotspot
1183 with_override_nashorn
1184 with_override_jdk
1185 with_import_hotspot
1186 with_import_modules
1187 enable_static_build
1188 with_toolchain_type
1189 with_extra_cflags
1190 with_extra_cxxflags
1191 with_extra_ldflags
1192 with_toolchain_version
1193 with_build_devkit
1194 with_jtreg
1195 enable_warnings_as_errors
1196 with_native_debug_symbols
1197 enable_debug_symbols
1198 enable_zip_debug_info
1199 enable_native_coverage
1200 enable_dtrace
1201 with_jvm_features
1202 with_jvm_interpreter
1203 enable_hotspot_gtest
1204 with_stdc__lib
1205 with_msvcr_dll
1206 with_msvcp_dll
1207 with_x
1208 with_cups
1209 with_cups_include
1210 with_freetype
1211 with_freetype_include
1212 with_freetype_lib
1213 with_freetype_src
1214 enable_freetype_bundling
1215 with_alsa
1216 with_alsa_include
1217 with_alsa_lib
1218 with_libffi
1219 with_libffi_include
1220 with_libffi_lib
1221 with_libjpeg
1222 with_giflib
1223 with_libpng
1224 with_zlib
1225 with_lcms
1226 with_dxsdk
1227 with_dxsdk_lib
1228 with_dxsdk_include
1229 enable_jtreg_failure_handler
1230 enable_generate_classlist
1231 with_num_cores
1232 with_memory_size
1233 with_jobs
1234 with_test_jobs
1235 with_boot_jdk_jvmargs
1236 with_sjavac_server_java
1237 enable_sjavac
1238 enable_javac_server
1239 enable_icecc
1240 enable_precompiled_headers
1241 enable_ccache
1242 with_ccache_dir
1243 '
1244       ac_precious_vars='build_alias
1245 host_alias
1246 target_alias
1247 BASENAME
1248 BASH
1249 CAT
1250 CHMOD
1251 CMP
1252 COMM
1253 CP
1254 CUT
1255 DATE
1256 DIFF
1257 DIRNAME
1258 ECHO
1259 EXPR
1260 FILE
1261 FIND
1262 HEAD
1263 GUNZIP
1264 GZIP
1265 LN
1266 LS
1267 MKDIR
1268 MKTEMP
1269 MV
1270 NAWK
1271 PRINTF
1272 RM
1273 RMDIR
1274 SH
1275 SORT
1276 TAIL
1277 TAR
1278 TEE
1279 TOUCH
1280 TR
1281 UNAME
1282 UNIQ
1283 WC
1284 WHICH
1285 XARGS
1286 AWK
1287 GREP
1288 EGREP
1289 FGREP
1290 SED
1291 CYGPATH
1292 READLINK
1293 DF
1294 CPIO
1295 NICE
1296 MAKE
1297 UNZIP
1298 ZIP
1299 LDD
1300 OTOOL
1301 READELF
1302 HG
1303 STAT
1304 TIME
1305 DTRACE
1306 PATCH
1307 DSYMUTIL
1308 XATTR
1309 CODESIGN
1310 SETFILE
1311 PKG_CONFIG
1312 JAVA
1313 JAVAC
1314 JAVAH
1315 JAR
1316 JARSIGNER
1317 CC
1318 CFLAGS
1319 LDFLAGS
1320 LIBS
1321 CPPFLAGS
1322 CXX
1323 CXXFLAGS
1324 CCC
1325 CPP
1326 CXXCPP
1327 AS
1328 AR
1329 LIPO
1330 STRIP
1331 NM
1332 GNM
1333 OBJCOPY
1334 OBJDUMP
1335 BUILD_CC
1336 BUILD_CXX
1337 BUILD_NM
1338 BUILD_AR
1339 BUILD_OBJCOPY
1340 BUILD_STRIP
1341 JTREGEXE
1342 XMKMF
1343 FREETYPE_CFLAGS
1344 FREETYPE_LIBS
1345 ALSA_CFLAGS
1346 ALSA_LIBS
1347 LIBFFI_CFLAGS
1348 LIBFFI_LIBS
1349 PNG_CFLAGS
1350 PNG_LIBS
1351 LCMS_CFLAGS
1352 LCMS_LIBS
1353 ICECC_CMD
1354 ICECC_CREATE_ENV
1355 ICECC_WRAPPER
1356 CCACHE'
1357 
1358 
1359 # Initialize some variables set by options.
1360 ac_init_help=
1361 ac_init_version=false
1362 ac_unrecognized_opts=
1363 ac_unrecognized_sep=
1364 # The variables have the same names as the options, with
1365 # dashes changed to underlines.
1366 cache_file=/dev/null
1367 exec_prefix=NONE
1368 no_create=
1369 no_recursion=
1370 prefix=NONE
1371 program_prefix=NONE
1372 program_suffix=NONE
1373 program_transform_name=s,x,x,
1374 silent=
1375 site=
1376 srcdir=
1377 verbose=
1378 x_includes=NONE
1379 x_libraries=NONE
1380 
1381 # Installation directory options.
1382 # These are left unexpanded so users can "make install exec_prefix=/foo"
1383 # and all the variables that are supposed to be based on exec_prefix
1384 # by default will actually change.
1385 # Use braces instead of parens because sh, perl, etc. also accept them.
1386 # (The list follows the same order as the GNU Coding Standards.)
1387 bindir='${exec_prefix}/bin'
1388 sbindir='${exec_prefix}/sbin'
1389 libexecdir='${exec_prefix}/libexec'
1390 datarootdir='${prefix}/share'
1391 datadir='${datarootdir}'
1392 sysconfdir='${prefix}/etc'
1393 sharedstatedir='${prefix}/com'
1394 localstatedir='${prefix}/var'
1395 includedir='${prefix}/include'
1396 oldincludedir='/usr/include'
1397 docdir='${datarootdir}/doc/${PACKAGE_TARNAME}'
1398 infodir='${datarootdir}/info'
1399 htmldir='${docdir}'
1400 dvidir='${docdir}'
1401 pdfdir='${docdir}'
1402 psdir='${docdir}'
1403 libdir='${exec_prefix}/lib'
1404 localedir='${datarootdir}/locale'
1405 mandir='${datarootdir}/man'
1406 
1407 ac_prev=
1408 ac_dashdash=
1409 for ac_option
1410 do
1411   # If the previous option needs an argument, assign it.
1412   if test -n "$ac_prev"; then
1413     eval $ac_prev=\$ac_option
1414     ac_prev=
1415     continue
1416   fi
1417 
1418   case $ac_option in
1419   *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
1420   *=)   ac_optarg= ;;
1421   *)    ac_optarg=yes ;;
1422   esac
1423 
1424   # Accept the important Cygnus configure options, so we can diagnose typos.
1425 
1426   case $ac_dashdash$ac_option in
1427   --)
1428     ac_dashdash=yes ;;
1429 
1430   -bindir | --bindir | --bindi | --bind | --bin | --bi)
1431     ac_prev=bindir ;;
1432   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
1433     bindir=$ac_optarg ;;
1434 
1435   -build | --build | --buil | --bui | --bu)
1436     ac_prev=build_alias ;;
1437   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
1438     build_alias=$ac_optarg ;;
1439 
1440   -cache-file | --cache-file | --cache-fil | --cache-fi \
1441   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
1442     ac_prev=cache_file ;;
1443   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
1444   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
1445     cache_file=$ac_optarg ;;
1446 
1447   --config-cache | -C)
1448     cache_file=config.cache ;;
1449 
1450   -datadir | --datadir | --datadi | --datad)
1451     ac_prev=datadir ;;
1452   -datadir=* | --datadir=* | --datadi=* | --datad=*)
1453     datadir=$ac_optarg ;;
1454 
1455   -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \
1456   | --dataroo | --dataro | --datar)
1457     ac_prev=datarootdir ;;
1458   -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \
1459   | --dataroot=* | --dataroo=* | --dataro=* | --datar=*)
1460     datarootdir=$ac_optarg ;;
1461 
1462   -disable-* | --disable-*)
1463     ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
1464     # Reject names that are not valid shell variable names.
1465     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1466       as_fn_error $? "invalid feature name: $ac_useropt"
1467     ac_useropt_orig=$ac_useropt
1468     ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1469     case $ac_user_opts in
1470       *"
1471 "enable_$ac_useropt"
1472 "*) ;;
1473       *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig"
1474          ac_unrecognized_sep=', ';;
1475     esac
1476     eval enable_$ac_useropt=no ;;
1477 
1478   -docdir | --docdir | --docdi | --doc | --do)
1479     ac_prev=docdir ;;
1480   -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*)
1481     docdir=$ac_optarg ;;
1482 
1483   -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv)
1484     ac_prev=dvidir ;;
1485   -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*)
1486     dvidir=$ac_optarg ;;
1487 
1488   -enable-* | --enable-*)
1489     ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
1490     # Reject names that are not valid shell variable names.
1491     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1492       as_fn_error $? "invalid feature name: $ac_useropt"
1493     ac_useropt_orig=$ac_useropt
1494     ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1495     case $ac_user_opts in
1496       *"
1497 "enable_$ac_useropt"
1498 "*) ;;
1499       *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig"
1500          ac_unrecognized_sep=', ';;
1501     esac
1502     eval enable_$ac_useropt=\$ac_optarg ;;
1503 
1504   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
1505   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
1506   | --exec | --exe | --ex)
1507     ac_prev=exec_prefix ;;
1508   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
1509   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
1510   | --exec=* | --exe=* | --ex=*)
1511     exec_prefix=$ac_optarg ;;
1512 
1513   -gas | --gas | --ga | --g)
1514     # Obsolete; use --with-gas.
1515     with_gas=yes ;;
1516 
1517   -help | --help | --hel | --he | -h)
1518     ac_init_help=long ;;
1519   -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
1520     ac_init_help=recursive ;;
1521   -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
1522     ac_init_help=short ;;
1523 
1524   -host | --host | --hos | --ho)
1525     ac_prev=host_alias ;;
1526   -host=* | --host=* | --hos=* | --ho=*)
1527     host_alias=$ac_optarg ;;
1528 
1529   -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht)
1530     ac_prev=htmldir ;;
1531   -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \
1532   | --ht=*)
1533     htmldir=$ac_optarg ;;
1534 
1535   -includedir | --includedir | --includedi | --included | --include \
1536   | --includ | --inclu | --incl | --inc)
1537     ac_prev=includedir ;;
1538   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
1539   | --includ=* | --inclu=* | --incl=* | --inc=*)
1540     includedir=$ac_optarg ;;
1541 
1542   -infodir | --infodir | --infodi | --infod | --info | --inf)
1543     ac_prev=infodir ;;
1544   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
1545     infodir=$ac_optarg ;;
1546 
1547   -libdir | --libdir | --libdi | --libd)
1548     ac_prev=libdir ;;
1549   -libdir=* | --libdir=* | --libdi=* | --libd=*)
1550     libdir=$ac_optarg ;;
1551 
1552   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
1553   | --libexe | --libex | --libe)
1554     ac_prev=libexecdir ;;
1555   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
1556   | --libexe=* | --libex=* | --libe=*)
1557     libexecdir=$ac_optarg ;;
1558 
1559   -localedir | --localedir | --localedi | --localed | --locale)
1560     ac_prev=localedir ;;
1561   -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*)
1562     localedir=$ac_optarg ;;
1563 
1564   -localstatedir | --localstatedir | --localstatedi | --localstated \
1565   | --localstate | --localstat | --localsta | --localst | --locals)
1566     ac_prev=localstatedir ;;
1567   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
1568   | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*)
1569     localstatedir=$ac_optarg ;;
1570 
1571   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
1572     ac_prev=mandir ;;
1573   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
1574     mandir=$ac_optarg ;;
1575 
1576   -nfp | --nfp | --nf)
1577     # Obsolete; use --without-fp.
1578     with_fp=no ;;
1579 
1580   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
1581   | --no-cr | --no-c | -n)
1582     no_create=yes ;;
1583 
1584   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
1585   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
1586     no_recursion=yes ;;
1587 
1588   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
1589   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
1590   | --oldin | --oldi | --old | --ol | --o)
1591     ac_prev=oldincludedir ;;
1592   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
1593   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
1594   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
1595     oldincludedir=$ac_optarg ;;
1596 
1597   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
1598     ac_prev=prefix ;;
1599   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
1600     prefix=$ac_optarg ;;
1601 
1602   -program-prefix | --program-prefix | --program-prefi | --program-pref \
1603   | --program-pre | --program-pr | --program-p)
1604     ac_prev=program_prefix ;;
1605   -program-prefix=* | --program-prefix=* | --program-prefi=* \
1606   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
1607     program_prefix=$ac_optarg ;;
1608 
1609   -program-suffix | --program-suffix | --program-suffi | --program-suff \
1610   | --program-suf | --program-su | --program-s)
1611     ac_prev=program_suffix ;;
1612   -program-suffix=* | --program-suffix=* | --program-suffi=* \
1613   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
1614     program_suffix=$ac_optarg ;;
1615 
1616   -program-transform-name | --program-transform-name \
1617   | --program-transform-nam | --program-transform-na \
1618   | --program-transform-n | --program-transform- \
1619   | --program-transform | --program-transfor \
1620   | --program-transfo | --program-transf \
1621   | --program-trans | --program-tran \
1622   | --progr-tra | --program-tr | --program-t)
1623     ac_prev=program_transform_name ;;
1624   -program-transform-name=* | --program-transform-name=* \
1625   | --program-transform-nam=* | --program-transform-na=* \
1626   | --program-transform-n=* | --program-transform-=* \
1627   | --program-transform=* | --program-transfor=* \
1628   | --program-transfo=* | --program-transf=* \
1629   | --program-trans=* | --program-tran=* \
1630   | --progr-tra=* | --program-tr=* | --program-t=*)
1631     program_transform_name=$ac_optarg ;;
1632 
1633   -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd)
1634     ac_prev=pdfdir ;;
1635   -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*)
1636     pdfdir=$ac_optarg ;;
1637 
1638   -psdir | --psdir | --psdi | --psd | --ps)
1639     ac_prev=psdir ;;
1640   -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)
1641     psdir=$ac_optarg ;;
1642 
1643   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1644   | -silent | --silent | --silen | --sile | --sil)
1645     silent=yes ;;
1646 
1647   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
1648     ac_prev=sbindir ;;
1649   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
1650   | --sbi=* | --sb=*)
1651     sbindir=$ac_optarg ;;
1652 
1653   -sharedstatedir | --sharedstatedir | --sharedstatedi \
1654   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
1655   | --sharedst | --shareds | --shared | --share | --shar \
1656   | --sha | --sh)
1657     ac_prev=sharedstatedir ;;
1658   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
1659   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
1660   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
1661   | --sha=* | --sh=*)
1662     sharedstatedir=$ac_optarg ;;
1663 
1664   -site | --site | --sit)
1665     ac_prev=site ;;
1666   -site=* | --site=* | --sit=*)
1667     site=$ac_optarg ;;
1668 
1669   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
1670     ac_prev=srcdir ;;
1671   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
1672     srcdir=$ac_optarg ;;
1673 
1674   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
1675   | --syscon | --sysco | --sysc | --sys | --sy)
1676     ac_prev=sysconfdir ;;
1677   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
1678   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
1679     sysconfdir=$ac_optarg ;;
1680 
1681   -target | --target | --targe | --targ | --tar | --ta | --t)
1682     ac_prev=target_alias ;;
1683   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
1684     target_alias=$ac_optarg ;;
1685 
1686   -v | -verbose | --verbose | --verbos | --verbo | --verb)
1687     verbose=yes ;;
1688 
1689   -version | --version | --versio | --versi | --vers | -V)
1690     ac_init_version=: ;;
1691 
1692   -with-* | --with-*)
1693     ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
1694     # Reject names that are not valid shell variable names.
1695     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1696       as_fn_error $? "invalid package name: $ac_useropt"
1697     ac_useropt_orig=$ac_useropt
1698     ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1699     case $ac_user_opts in
1700       *"
1701 "with_$ac_useropt"
1702 "*) ;;
1703       *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig"
1704          ac_unrecognized_sep=', ';;
1705     esac
1706     eval with_$ac_useropt=\$ac_optarg ;;
1707 
1708   -without-* | --without-*)
1709     ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'`
1710     # Reject names that are not valid shell variable names.
1711     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1712       as_fn_error $? "invalid package name: $ac_useropt"
1713     ac_useropt_orig=$ac_useropt
1714     ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1715     case $ac_user_opts in
1716       *"
1717 "with_$ac_useropt"
1718 "*) ;;
1719       *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig"
1720          ac_unrecognized_sep=', ';;
1721     esac
1722     eval with_$ac_useropt=no ;;
1723 
1724   --x)
1725     # Obsolete; use --with-x.
1726     with_x=yes ;;
1727 
1728   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
1729   | --x-incl | --x-inc | --x-in | --x-i)
1730     ac_prev=x_includes ;;
1731   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
1732   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
1733     x_includes=$ac_optarg ;;
1734 
1735   -x-libraries | --x-libraries | --x-librarie | --x-librari \
1736   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
1737     ac_prev=x_libraries ;;
1738   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
1739   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
1740     x_libraries=$ac_optarg ;;
1741 
1742   -*) as_fn_error $? "unrecognized option: \`$ac_option'
1743 Try \`$0 --help' for more information"
1744     ;;
1745 
1746   *=*)
1747     ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
1748     # Reject names that are not valid shell variable names.
1749     case $ac_envvar in #(
1750       '' | [0-9]* | *[!_$as_cr_alnum]* )
1751       as_fn_error $? "invalid variable name: \`$ac_envvar'" ;;
1752     esac
1753     eval $ac_envvar=\$ac_optarg
1754     export $ac_envvar ;;
1755 
1756   *)
1757     # FIXME: should be removed in autoconf 3.0.
1758     $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2
1759     expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
1760       $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2
1761     : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}"
1762     ;;
1763 
1764   esac
1765 done
1766 
1767 if test -n "$ac_prev"; then
1768   ac_option=--`echo $ac_prev | sed 's/_/-/g'`
1769   as_fn_error $? "missing argument to $ac_option"
1770 fi
1771 
1772 if test -n "$ac_unrecognized_opts"; then
1773   case $enable_option_checking in
1774     no) ;;
1775     fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;;
1776     *)     $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
1777   esac
1778 fi
1779 
1780 # Check all directory arguments for consistency.
1781 for ac_var in   exec_prefix prefix bindir sbindir libexecdir datarootdir \
1782                 datadir sysconfdir sharedstatedir localstatedir includedir \
1783                 oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
1784                 libdir localedir mandir
1785 do
1786   eval ac_val=\$$ac_var
1787   # Remove trailing slashes.
1788   case $ac_val in
1789     */ )
1790       ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'`
1791       eval $ac_var=\$ac_val;;
1792   esac
1793   # Be sure to have absolute directory names.
1794   case $ac_val in
1795     [\\/$]* | ?:[\\/]* )  continue;;
1796     NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
1797   esac
1798   as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val"
1799 done
1800 
1801 # There might be people who depend on the old broken behavior: `$host'
1802 # used to hold the argument of --host etc.
1803 # FIXME: To remove some day.
1804 build=$build_alias
1805 host=$host_alias
1806 target=$target_alias
1807 
1808 # FIXME: To remove some day.
1809 if test "x$host_alias" != x; then
1810   if test "x$build_alias" = x; then
1811     cross_compiling=maybe
1812   elif test "x$build_alias" != "x$host_alias"; then
1813     cross_compiling=yes
1814   fi
1815 fi
1816 
1817 ac_tool_prefix=
1818 test -n "$host_alias" && ac_tool_prefix=$host_alias-
1819 
1820 test "$silent" = yes && exec 6>/dev/null
1821 
1822 
1823 ac_pwd=`pwd` && test -n "$ac_pwd" &&
1824 ac_ls_di=`ls -di .` &&
1825 ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
1826   as_fn_error $? "working directory cannot be determined"
1827 test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
1828   as_fn_error $? "pwd does not report name of working directory"
1829 
1830 
1831 # Find the source files, if location was not specified.
1832 if test -z "$srcdir"; then
1833   ac_srcdir_defaulted=yes
1834   # Try the directory containing this script, then the parent directory.
1835   ac_confdir=`$as_dirname -- "$as_myself" ||
1836 $as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
1837          X"$as_myself" : 'X\(//\)[^/]' \| \
1838          X"$as_myself" : 'X\(//\)$' \| \
1839          X"$as_myself" : 'X\(/\)' \| . 2>/dev/null ||
1840 $as_echo X"$as_myself" |
1841     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
1842             s//\1/
1843             q
1844           }
1845           /^X\(\/\/\)[^/].*/{
1846             s//\1/
1847             q
1848           }
1849           /^X\(\/\/\)$/{
1850             s//\1/
1851             q
1852           }
1853           /^X\(\/\).*/{
1854             s//\1/
1855             q
1856           }
1857           s/.*/./; q'`
1858   srcdir=$ac_confdir
1859   if test ! -r "$srcdir/$ac_unique_file"; then
1860     srcdir=..
1861   fi
1862 else
1863   ac_srcdir_defaulted=no
1864 fi
1865 if test ! -r "$srcdir/$ac_unique_file"; then
1866   test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
1867   as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir"
1868 fi
1869 ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
1870 ac_abs_confdir=`(
1871         cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg"
1872         pwd)`
1873 # When building in place, set srcdir=.
1874 if test "$ac_abs_confdir" = "$ac_pwd"; then
1875   srcdir=.
1876 fi
1877 # Remove unnecessary trailing slashes from srcdir.
1878 # Double slashes in file names in object file debugging info
1879 # mess up M-x gdb in Emacs.
1880 case $srcdir in
1881 */) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;;
1882 esac
1883 for ac_var in $ac_precious_vars; do
1884   eval ac_env_${ac_var}_set=\${${ac_var}+set}
1885   eval ac_env_${ac_var}_value=\$${ac_var}
1886   eval ac_cv_env_${ac_var}_set=\${${ac_var}+set}
1887   eval ac_cv_env_${ac_var}_value=\$${ac_var}
1888 done
1889 
1890 #
1891 # Report the --help message.
1892 #
1893 if test "$ac_init_help" = "long"; then
1894   # Omit some internal or obsolete options to make the list less imposing.
1895   # This message is too long to be a string in the A/UX 3.1 sh.
1896   cat <<_ACEOF
1897 \`configure' configures OpenJDK jdk9 to adapt to many kinds of systems.
1898 
1899 Usage: $0 [OPTION]... [VAR=VALUE]...
1900 
1901 To assign environment variables (e.g., CC, CFLAGS...), specify them as
1902 VAR=VALUE.  See below for descriptions of some of the useful variables.
1903 
1904 Defaults for the options are specified in brackets.
1905 
1906 Configuration:
1907   -h, --help              display this help and exit
1908       --help=short        display options specific to this package
1909       --help=recursive    display the short help of all the included packages
1910   -V, --version           display version information and exit
1911   -q, --quiet, --silent   do not print \`checking ...' messages
1912       --cache-file=FILE   cache test results in FILE [disabled]
1913   -C, --config-cache      alias for \`--cache-file=config.cache'
1914   -n, --no-create         do not create output files
1915       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
1916 
1917 Installation directories:
1918   --prefix=PREFIX         install architecture-independent files in PREFIX
1919                           [$ac_default_prefix]
1920   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
1921                           [PREFIX]
1922 
1923 By default, \`make install' will install all the files in
1924 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
1925 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
1926 for instance \`--prefix=\$HOME'.
1927 
1928 For better control, use the options below.
1929 
1930 Fine tuning of the installation directories:
1931   --bindir=DIR            user executables [EPREFIX/bin]
1932   --sbindir=DIR           system admin executables [EPREFIX/sbin]
1933   --libexecdir=DIR        program executables [EPREFIX/libexec]
1934   --sysconfdir=DIR        read-only single-machine data [PREFIX/etc]
1935   --sharedstatedir=DIR    modifiable architecture-independent data [PREFIX/com]
1936   --localstatedir=DIR     modifiable single-machine data [PREFIX/var]
1937   --libdir=DIR            object code libraries [EPREFIX/lib]
1938   --includedir=DIR        C header files [PREFIX/include]
1939   --oldincludedir=DIR     C header files for non-gcc [/usr/include]
1940   --datarootdir=DIR       read-only arch.-independent data root [PREFIX/share]
1941   --datadir=DIR           read-only architecture-independent data [DATAROOTDIR]
1942   --infodir=DIR           info documentation [DATAROOTDIR/info]
1943   --localedir=DIR         locale-dependent data [DATAROOTDIR/locale]
1944   --mandir=DIR            man documentation [DATAROOTDIR/man]
1945   --docdir=DIR            documentation root [DATAROOTDIR/doc/openjdk]
1946   --htmldir=DIR           html documentation [DOCDIR]
1947   --dvidir=DIR            dvi documentation [DOCDIR]
1948   --pdfdir=DIR            pdf documentation [DOCDIR]
1949   --psdir=DIR             ps documentation [DOCDIR]
1950 _ACEOF
1951 
1952   cat <<\_ACEOF
1953 
1954 X features:
1955   --x-includes=DIR    X include files are in DIR
1956   --x-libraries=DIR   X library files are in DIR
1957 
1958 System types:
1959   --build=BUILD     configure for building on BUILD [guessed]
1960   --host=HOST       cross-compile to build programs to run on HOST [BUILD]
1961   --target=TARGET   configure for building compilers for TARGET [HOST]
1962 _ACEOF
1963 fi
1964 
1965 if test -n "$ac_init_help"; then
1966   case $ac_init_help in
1967      short | recursive ) echo "Configuration of OpenJDK jdk9:";;
1968    esac
1969   cat <<\_ACEOF
1970 
1971 Optional Features:
1972   --disable-option-checking  ignore unrecognized --enable/--with options
1973   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
1974   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
1975   --enable-openjdk-only   suppress building custom source even if present
1976                           [disabled]
1977   --enable-debug          set the debug level to fastdebug (shorthand for
1978                           --with-debug-level=fastdebug) [disabled]
1979   --disable-headful       disable building headful support (graphical UI
1980                           support) [enabled]
1981   --enable-unlimited-crypto
1982                           Enable unlimited crypto policy [disabled]
1983   --disable-keep-packaged-modules
1984                           Do not keep packaged modules in jdk image [enable]
1985   --enable-static-build   enable static library build [disabled]
1986   --disable-warnings-as-errors
1987                           do not consider native warnings to be an error
1988                           [enabled]
1989   --enable-debug-symbols  Deprecated. Option is kept for backwards
1990                           compatibility and is ignored
1991   --enable-zip-debug-info Deprecated. Option is kept for backwards
1992                           compatibility and is ignored
1993   --enable-native-coverage
1994                           enable native compilation with code coverage
1995                           data[disabled]
1996   --enable-dtrace[=yes/no/auto]
1997                           enable dtrace. Default is auto, where dtrace is
1998                           enabled if all dependencies are present.
1999   --disable-hotspot-gtest Disables building of the Hotspot unit tests
2000   --disable-freetype-bundling
2001                           disable bundling of the freetype library with the
2002                           build result [enabled on Windows or when using
2003                           --with-freetype, disabled otherwise]
2004   --enable-jtreg-failure-handler
2005                           forces build of the jtreg failure handler to be
2006                           enabled, missing dependencies become fatal errors.
2007                           Default is auto, where the failure handler is built
2008                           if all dependencies are present and otherwise just
2009                           disabled.
2010   --disable-generate-classlist
2011                           forces enabling or disabling of the generation of a
2012                           CDS classlist at build time. Default is to generate
2013                           it when either the server or client JVMs are built.
2014   --enable-sjavac         use sjavac to do fast incremental compiles
2015                           [disabled]
2016   --disable-javac-server  disable javac server [enabled]
2017   --enable-icecc          enable distribted compilation of native code using
2018                           icecc/icecream [disabled]
2019   --disable-precompiled-headers
2020                           disable using precompiled headers when compiling C++
2021                           [enabled]
2022   --enable-ccache         enable using ccache to speed up recompilations
2023                           [disabled]
2024 
2025 Optional Packages:
2026   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
2027   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
2028   --with-target-bits      build 32-bit or 64-bit binaries (for platforms that
2029                           support it), e.g. --with-target-bits=32 [guessed]
2030   --with-custom-make-dir  Deprecated. Option is kept for backwards
2031                           compatibility and is ignored
2032   --with-jdk-variant      JDK variant to build (normal) [normal]
2033   --with-debug-level      set the debug level (release, fastdebug, slowdebug,
2034                           optimized) [release]
2035   --with-jvm-variants     JVM variants (separated by commas) to build
2036                           (server,client,minimal,core,zero,zeroshark,custom)
2037                           [server]
2038   --with-devkit           use this devkit for compilers, tools and resources
2039   --with-sys-root         alias for --with-sysroot for backwards compatability
2040   --with-sysroot          use this directory as sysroot
2041   --with-tools-dir        alias for --with-toolchain-path for backwards
2042                           compatibility
2043   --with-toolchain-path   prepend these directories when searching for
2044                           toolchain binaries (compilers etc)
2045   --with-extra-path       prepend these directories to the default path
2046   --with-sdk-name         use the platform SDK of the given name. [macosx]
2047   --with-conf-name        use this as the name of the configuration [generated
2048                           from important configuration options]
2049   --with-output-sync      set make output sync type if supported by make.
2050                           [recurse]
2051   --with-default-make-target
2052                           set the default make target [exploded-image]
2053   --with-cacerts-file     specify alternative cacerts file
2054   --with-copyright-year   Set copyright year value for build [current year]
2055   --with-milestone        Deprecated. Option is kept for backwards
2056                           compatibility and is ignored
2057   --with-update-version   Deprecated. Option is kept for backwards
2058                           compatibility and is ignored
2059   --with-user-release-suffix
2060                           Deprecated. Option is kept for backwards
2061                           compatibility and is ignored
2062   --with-build-number     Deprecated. Option is kept for backwards
2063                           compatibility and is ignored
2064   --with-version-string   Set version string [calculated]
2065   --with-version-pre      Set the base part of the version 'PRE' field
2066                           (pre-release identifier) ['internal']
2067   --with-version-opt      Set version 'OPT' field (build metadata)
2068                           [<timestamp>.<user>.<dirname>]
2069   --with-version-build    Set version 'BUILD' field (build number) [not
2070                           specified]
2071   --with-version-major    Set version 'MAJOR' field (first number) [current
2072                           source value]
2073   --with-version-minor    Set version 'MINOR' field (second number) [current
2074                           source value]
2075   --with-version-security Set version 'SECURITY' field (third number) [current
2076                           source value]
2077   --with-version-patch    Set version 'PATCH' field (fourth number) [not
2078                           specified]
2079   --with-boot-jdk         path to Boot JDK (used to bootstrap build) [probed]
2080   --with-build-jdk        path to JDK of same version as is being built[the
2081                           newly built JDK]
2082   --with-add-source-root  Deprecated. Option is kept for backwards
2083                           compatibility and is ignored
2084   --with-override-source-root
2085                           Deprecated. Option is kept for backwards
2086                           compatibility and is ignored
2087   --with-adds-and-overrides
2088                           Deprecated. Option is kept for backwards
2089                           compatibility and is ignored
2090   --with-override-langtools
2091                           Deprecated. Option is kept for backwards
2092                           compatibility and is ignored
2093   --with-override-corba   Deprecated. Option is kept for backwards
2094                           compatibility and is ignored
2095   --with-override-jaxp    Deprecated. Option is kept for backwards
2096                           compatibility and is ignored
2097   --with-override-jaxws   Deprecated. Option is kept for backwards
2098                           compatibility and is ignored
2099   --with-override-hotspot Deprecated. Option is kept for backwards
2100                           compatibility and is ignored
2101   --with-override-nashorn Deprecated. Option is kept for backwards
2102                           compatibility and is ignored
2103   --with-override-jdk     Deprecated. Option is kept for backwards
2104                           compatibility and is ignored
2105   --with-import-hotspot   import hotspot binaries from this jdk image or
2106                           hotspot build dist dir instead of building from
2107                           source
2108   --with-import-modules   import a set of prebuilt modules either as a zip
2109                           file or an exploded directory
2110   --with-toolchain-type   the toolchain type (or family) to use, use '--help'
2111                           to show possible values [platform dependent]
2112   --with-extra-cflags     extra flags to be used when compiling jdk c-files
2113   --with-extra-cxxflags   extra flags to be used when compiling jdk c++-files
2114   --with-extra-ldflags    extra flags to be used when linking jdk
2115   --with-toolchain-version
2116                           the version of the toolchain to look for, use
2117                           '--help' to show possible values [platform
2118                           dependent]
2119   --with-build-devkit     Devkit to use for the build platform toolchain
2120   --with-jtreg            Regression Test Harness [probed]
2121   --with-native-debug-symbols
2122                           set the native debug symbol configuration (none,
2123                           internal, external, zipped) [varying]
2124   --with-jvm-features     additional JVM features to enable (separated by
2125                           comma), use '--help' to show possible values [none]
2126   --with-jvm-interpreter  Deprecated. Option is kept for backwards
2127                           compatibility and is ignored
2128   --with-stdc++lib=<static>,<dynamic>,<default>
2129                           force linking of the C++ runtime on Linux to either
2130                           static or dynamic, default is static with dynamic as
2131                           fallback
2132   --with-msvcr-dll        path to microsoft C runtime dll (msvcr*.dll)
2133                           (Windows only) [probed]
2134   --with-msvcp-dll        path to microsoft C++ runtime dll (msvcp*.dll)
2135                           (Windows only) [probed]
2136   --with-x                use the X Window System
2137   --with-cups             specify prefix directory for the cups package
2138                           (expecting the headers under PATH/include)
2139   --with-cups-include     specify directory for the cups include files
2140   --with-freetype         specify prefix directory for the freetype package
2141                           (expecting the libraries under PATH/lib and the
2142                           headers under PATH/include)
2143   --with-freetype-include specify directory for the freetype include files
2144   --with-freetype-lib     specify directory for the freetype library
2145   --with-freetype-src     specify directory with freetype sources to
2146                           automatically build the library (experimental,
2147                           Windows-only)
2148   --with-alsa             specify prefix directory for the alsa package
2149                           (expecting the libraries under PATH/lib and the
2150                           headers under PATH/include)
2151   --with-alsa-include     specify directory for the alsa include files
2152   --with-alsa-lib         specify directory for the alsa library
2153   --with-libffi           specify prefix directory for the libffi package
2154                           (expecting the libraries under PATH/lib and the
2155                           headers under PATH/include)
2156   --with-libffi-include   specify directory for the libffi include files
2157   --with-libffi-lib       specify directory for the libffi library
2158   --with-libjpeg          use libjpeg from build system or OpenJDK source
2159                           (system, bundled) [bundled]
2160   --with-giflib           use giflib from build system or OpenJDK source
2161                           (system, bundled) [bundled]
2162   --with-libpng           use libpng from build system or OpenJDK source
2163                           (system, bundled) [bundled]
2164   --with-zlib             use zlib from build system or OpenJDK source
2165                           (system, bundled) [bundled]
2166   --with-lcms             use lcms2 from build system or OpenJDK source
2167                           (system, bundled) [bundled]
2168   --with-dxsdk            Deprecated. Option is kept for backwards
2169                           compatibility and is ignored
2170   --with-dxsdk-lib        Deprecated. Option is kept for backwards
2171                           compatibility and is ignored
2172   --with-dxsdk-include    Deprecated. Option is kept for backwards
2173                           compatibility and is ignored
2174   --with-num-cores        number of cores in the build system, e.g.
2175                           --with-num-cores=8 [probed]
2176   --with-memory-size      memory (in MB) available in the build system, e.g.
2177                           --with-memory-size=1024 [probed]
2178   --with-jobs             number of parallel jobs to let make run [calculated
2179                           based on cores and memory]
2180   --with-test-jobs        number of parallel tests jobs to run [based on build
2181                           jobs]
2182   --with-boot-jdk-jvmargs specify JVM arguments to be passed to all java
2183                           invocations of boot JDK, overriding the default
2184                           values, e.g --with-boot-jdk-jvmargs="-Xmx8G
2185                           -enableassertions"
2186   --with-sjavac-server-java
2187                           use this java binary for running the sjavac
2188                           background server [Boot JDK java]
2189   --with-ccache-dir       where to store ccache files [~/.ccache]
2190 
2191 Some influential environment variables:
2192   BASENAME    Override default value for BASENAME
2193   BASH        Override default value for BASH
2194   CAT         Override default value for CAT
2195   CHMOD       Override default value for CHMOD
2196   CMP         Override default value for CMP
2197   COMM        Override default value for COMM
2198   CP          Override default value for CP
2199   CUT         Override default value for CUT
2200   DATE        Override default value for DATE
2201   DIFF        Override default value for DIFF
2202   DIRNAME     Override default value for DIRNAME
2203   ECHO        Override default value for ECHO
2204   EXPR        Override default value for EXPR
2205   FILE        Override default value for FILE
2206   FIND        Override default value for FIND
2207   HEAD        Override default value for HEAD
2208   GUNZIP      Override default value for GUNZIP
2209   GZIP        Override default value for GZIP
2210   LN          Override default value for LN
2211   LS          Override default value for LS
2212   MKDIR       Override default value for MKDIR
2213   MKTEMP      Override default value for MKTEMP
2214   MV          Override default value for MV
2215   NAWK        Override default value for NAWK
2216   PRINTF      Override default value for PRINTF
2217   RM          Override default value for RM
2218   RMDIR       Override default value for RMDIR
2219   SH          Override default value for SH
2220   SORT        Override default value for SORT
2221   TAIL        Override default value for TAIL
2222   TAR         Override default value for TAR
2223   TEE         Override default value for TEE
2224   TOUCH       Override default value for TOUCH
2225   TR          Override default value for TR
2226   UNAME       Override default value for UNAME
2227   UNIQ        Override default value for UNIQ
2228   WC          Override default value for WC
2229   WHICH       Override default value for WHICH
2230   XARGS       Override default value for XARGS
2231   AWK         Override default value for AWK
2232   GREP        Override default value for GREP
2233   EGREP       Override default value for EGREP
2234   FGREP       Override default value for FGREP
2235   SED         Override default value for SED
2236   CYGPATH     Override default value for CYGPATH
2237   READLINK    Override default value for READLINK
2238   DF          Override default value for DF
2239   CPIO        Override default value for CPIO
2240   NICE        Override default value for NICE
2241   MAKE        Override default value for MAKE
2242   UNZIP       Override default value for UNZIP
2243   ZIP         Override default value for ZIP
2244   LDD         Override default value for LDD
2245   OTOOL       Override default value for OTOOL
2246   READELF     Override default value for READELF
2247   HG          Override default value for HG
2248   STAT        Override default value for STAT
2249   TIME        Override default value for TIME
2250   DTRACE      Override default value for DTRACE
2251   PATCH       Override default value for PATCH
2252   DSYMUTIL    Override default value for DSYMUTIL
2253   XATTR       Override default value for XATTR
2254   CODESIGN    Override default value for CODESIGN
2255   SETFILE     Override default value for SETFILE
2256   PKG_CONFIG  path to pkg-config utility
2257   JAVA        Override default value for JAVA
2258   JAVAC       Override default value for JAVAC
2259   JAVAH       Override default value for JAVAH
2260   JAR         Override default value for JAR
2261   JARSIGNER   Override default value for JARSIGNER
2262   CC          C compiler command
2263   CFLAGS      C compiler flags
2264   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
2265               nonstandard directory <lib dir>
2266   LIBS        libraries to pass to the linker, e.g. -l<library>
2267   CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
2268               you have headers in a nonstandard directory <include dir>
2269   CXX         C++ compiler command
2270   CXXFLAGS    C++ compiler flags
2271   CPP         C preprocessor
2272   CXXCPP      C++ preprocessor
2273   AS          Override default value for AS
2274   AR          Override default value for AR
2275   LIPO        Override default value for LIPO
2276   STRIP       Override default value for STRIP
2277   NM          Override default value for NM
2278   GNM         Override default value for GNM
2279   OBJCOPY     Override default value for OBJCOPY
2280   OBJDUMP     Override default value for OBJDUMP
2281   BUILD_CC    Override default value for BUILD_CC
2282   BUILD_CXX   Override default value for BUILD_CXX
2283   BUILD_NM    Override default value for BUILD_NM
2284   BUILD_AR    Override default value for BUILD_AR
2285   BUILD_OBJCOPY
2286               Override default value for BUILD_OBJCOPY
2287   BUILD_STRIP Override default value for BUILD_STRIP
2288   JTREGEXE    Override default value for JTREGEXE
2289   XMKMF       Path to xmkmf, Makefile generator for X Window System
2290   FREETYPE_CFLAGS
2291               C compiler flags for FREETYPE, overriding pkg-config
2292   FREETYPE_LIBS
2293               linker flags for FREETYPE, overriding pkg-config
2294   ALSA_CFLAGS C compiler flags for ALSA, overriding pkg-config
2295   ALSA_LIBS   linker flags for ALSA, overriding pkg-config
2296   LIBFFI_CFLAGS
2297               C compiler flags for LIBFFI, overriding pkg-config
2298   LIBFFI_LIBS linker flags for LIBFFI, overriding pkg-config
2299   PNG_CFLAGS  C compiler flags for PNG, overriding pkg-config
2300   PNG_LIBS    linker flags for PNG, overriding pkg-config
2301   LCMS_CFLAGS C compiler flags for LCMS, overriding pkg-config
2302   LCMS_LIBS   linker flags for LCMS, overriding pkg-config
2303   ICECC_CMD   Override default value for ICECC_CMD
2304   ICECC_CREATE_ENV
2305               Override default value for ICECC_CREATE_ENV
2306   ICECC_WRAPPER
2307               Override default value for ICECC_WRAPPER
2308   CCACHE      Override default value for CCACHE
2309 
2310 Use these variables to override the choices made by `configure' or to help
2311 it to find libraries and programs with nonstandard names/locations.
2312 
2313 Report bugs to <build-dev@openjdk.java.net>.
2314 OpenJDK home page: <http://openjdk.java.net>.
2315 _ACEOF
2316 ac_status=$?
2317 fi
2318 
2319 if test "$ac_init_help" = "recursive"; then
2320   # If there are subdirs, report their specific --help.
2321   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
2322     test -d "$ac_dir" ||
2323       { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } ||
2324       continue
2325     ac_builddir=.
2326 
2327 case "$ac_dir" in
2328 .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
2329 *)
2330   ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
2331   # A ".." for each directory in $ac_dir_suffix.
2332   ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
2333   case $ac_top_builddir_sub in
2334   "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
2335   *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
2336   esac ;;
2337 esac
2338 ac_abs_top_builddir=$ac_pwd
2339 ac_abs_builddir=$ac_pwd$ac_dir_suffix
2340 # for backward compatibility:
2341 ac_top_builddir=$ac_top_build_prefix
2342 
2343 case $srcdir in
2344   .)  # We are building in place.
2345     ac_srcdir=.
2346     ac_top_srcdir=$ac_top_builddir_sub
2347     ac_abs_top_srcdir=$ac_pwd ;;
2348   [\\/]* | ?:[\\/]* )  # Absolute name.
2349     ac_srcdir=$srcdir$ac_dir_suffix;
2350     ac_top_srcdir=$srcdir
2351     ac_abs_top_srcdir=$srcdir ;;
2352   *) # Relative name.
2353     ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
2354     ac_top_srcdir=$ac_top_build_prefix$srcdir
2355     ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
2356 esac
2357 ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
2358 
2359     cd "$ac_dir" || { ac_status=$?; continue; }
2360     # Check for guested configure.
2361     if test -f "$ac_srcdir/configure.gnu"; then
2362       echo &&
2363       $SHELL "$ac_srcdir/configure.gnu" --help=recursive
2364     elif test -f "$ac_srcdir/configure"; then
2365       echo &&
2366       $SHELL "$ac_srcdir/configure" --help=recursive
2367     else
2368       $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
2369     fi || ac_status=$?
2370     cd "$ac_pwd" || { ac_status=$?; break; }
2371   done
2372 fi
2373 
2374 test -n "$ac_init_help" && exit $ac_status
2375 if $ac_init_version; then
2376   cat <<\_ACEOF
2377 OpenJDK configure jdk9
2378 generated by GNU Autoconf 2.69
2379 
2380 Copyright (C) 2012 Free Software Foundation, Inc.
2381 This configure script is free software; the Free Software Foundation
2382 gives unlimited permission to copy, distribute and modify it.
2383 _ACEOF
2384   exit
2385 fi
2386 
2387 ## ------------------------ ##
2388 ## Autoconf initialization. ##
2389 ## ------------------------ ##
2390 
2391 # ac_fn_c_try_compile LINENO
2392 # --------------------------
2393 # Try to compile conftest.$ac_ext, and return whether this succeeded.
2394 ac_fn_c_try_compile ()
2395 {
2396   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2397   rm -f conftest.$ac_objext
2398   if { { ac_try="$ac_compile"
2399 case "(($ac_try" in
2400   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2401   *) ac_try_echo=$ac_try;;
2402 esac
2403 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2404 $as_echo "$ac_try_echo"; } >&5
2405   (eval "$ac_compile") 2>conftest.err
2406   ac_status=$?
2407   if test -s conftest.err; then
2408     grep -v '^ *+' conftest.err >conftest.er1
2409     cat conftest.er1 >&5
2410     mv -f conftest.er1 conftest.err
2411   fi
2412   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2413   test $ac_status = 0; } && {
2414          test -z "$ac_c_werror_flag" ||
2415          test ! -s conftest.err
2416        } && test -s conftest.$ac_objext; then :
2417   ac_retval=0
2418 else
2419   $as_echo "$as_me: failed program was:" >&5
2420 sed 's/^/| /' conftest.$ac_ext >&5
2421 
2422         ac_retval=1
2423 fi
2424   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2425   as_fn_set_status $ac_retval
2426 
2427 } # ac_fn_c_try_compile
2428 
2429 # ac_fn_cxx_try_compile LINENO
2430 # ----------------------------
2431 # Try to compile conftest.$ac_ext, and return whether this succeeded.
2432 ac_fn_cxx_try_compile ()
2433 {
2434   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2435   rm -f conftest.$ac_objext
2436   if { { ac_try="$ac_compile"
2437 case "(($ac_try" in
2438   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2439   *) ac_try_echo=$ac_try;;
2440 esac
2441 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2442 $as_echo "$ac_try_echo"; } >&5
2443   (eval "$ac_compile") 2>conftest.err
2444   ac_status=$?
2445   if test -s conftest.err; then
2446     grep -v '^ *+' conftest.err >conftest.er1
2447     cat conftest.er1 >&5
2448     mv -f conftest.er1 conftest.err
2449   fi
2450   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2451   test $ac_status = 0; } && {
2452          test -z "$ac_cxx_werror_flag" ||
2453          test ! -s conftest.err
2454        } && test -s conftest.$ac_objext; then :
2455   ac_retval=0
2456 else
2457   $as_echo "$as_me: failed program was:" >&5
2458 sed 's/^/| /' conftest.$ac_ext >&5
2459 
2460         ac_retval=1
2461 fi
2462   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2463   as_fn_set_status $ac_retval
2464 
2465 } # ac_fn_cxx_try_compile
2466 
2467 # ac_fn_c_try_cpp LINENO
2468 # ----------------------
2469 # Try to preprocess conftest.$ac_ext, and return whether this succeeded.
2470 ac_fn_c_try_cpp ()
2471 {
2472   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2473   if { { ac_try="$ac_cpp conftest.$ac_ext"
2474 case "(($ac_try" in
2475   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2476   *) ac_try_echo=$ac_try;;
2477 esac
2478 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2479 $as_echo "$ac_try_echo"; } >&5
2480   (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
2481   ac_status=$?
2482   if test -s conftest.err; then
2483     grep -v '^ *+' conftest.err >conftest.er1
2484     cat conftest.er1 >&5
2485     mv -f conftest.er1 conftest.err
2486   fi
2487   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2488   test $ac_status = 0; } > conftest.i && {
2489          test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
2490          test ! -s conftest.err
2491        }; then :
2492   ac_retval=0
2493 else
2494   $as_echo "$as_me: failed program was:" >&5
2495 sed 's/^/| /' conftest.$ac_ext >&5
2496 
2497     ac_retval=1
2498 fi
2499   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2500   as_fn_set_status $ac_retval
2501 
2502 } # ac_fn_c_try_cpp
2503 
2504 # ac_fn_cxx_try_cpp LINENO
2505 # ------------------------
2506 # Try to preprocess conftest.$ac_ext, and return whether this succeeded.
2507 ac_fn_cxx_try_cpp ()
2508 {
2509   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2510   if { { ac_try="$ac_cpp conftest.$ac_ext"
2511 case "(($ac_try" in
2512   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2513   *) ac_try_echo=$ac_try;;
2514 esac
2515 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2516 $as_echo "$ac_try_echo"; } >&5
2517   (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
2518   ac_status=$?
2519   if test -s conftest.err; then
2520     grep -v '^ *+' conftest.err >conftest.er1
2521     cat conftest.er1 >&5
2522     mv -f conftest.er1 conftest.err
2523   fi
2524   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2525   test $ac_status = 0; } > conftest.i && {
2526          test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
2527          test ! -s conftest.err
2528        }; then :
2529   ac_retval=0
2530 else
2531   $as_echo "$as_me: failed program was:" >&5
2532 sed 's/^/| /' conftest.$ac_ext >&5
2533 
2534     ac_retval=1
2535 fi
2536   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2537   as_fn_set_status $ac_retval
2538 
2539 } # ac_fn_cxx_try_cpp
2540 
2541 # ac_fn_c_try_link LINENO
2542 # -----------------------
2543 # Try to link conftest.$ac_ext, and return whether this succeeded.
2544 ac_fn_c_try_link ()
2545 {
2546   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2547   rm -f conftest.$ac_objext conftest$ac_exeext
2548   if { { ac_try="$ac_link"
2549 case "(($ac_try" in
2550   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2551   *) ac_try_echo=$ac_try;;
2552 esac
2553 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2554 $as_echo "$ac_try_echo"; } >&5
2555   (eval "$ac_link") 2>conftest.err
2556   ac_status=$?
2557   if test -s conftest.err; then
2558     grep -v '^ *+' conftest.err >conftest.er1
2559     cat conftest.er1 >&5
2560     mv -f conftest.er1 conftest.err
2561   fi
2562   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2563   test $ac_status = 0; } && {
2564          test -z "$ac_c_werror_flag" ||
2565          test ! -s conftest.err
2566        } && test -s conftest$ac_exeext && {
2567          test "$cross_compiling" = yes ||
2568          test -x conftest$ac_exeext
2569        }; then :
2570   ac_retval=0
2571 else
2572   $as_echo "$as_me: failed program was:" >&5
2573 sed 's/^/| /' conftest.$ac_ext >&5
2574 
2575         ac_retval=1
2576 fi
2577   # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
2578   # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
2579   # interfere with the next link command; also delete a directory that is
2580   # left behind by Apple's compiler.  We do this before executing the actions.
2581   rm -rf conftest.dSYM conftest_ipa8_conftest.oo
2582   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2583   as_fn_set_status $ac_retval
2584 
2585 } # ac_fn_c_try_link
2586 
2587 # ac_fn_cxx_check_header_mongrel LINENO HEADER VAR INCLUDES
2588 # ---------------------------------------------------------
2589 # Tests whether HEADER exists, giving a warning if it cannot be compiled using
2590 # the include files in INCLUDES and setting the cache variable VAR
2591 # accordingly.
2592 ac_fn_cxx_check_header_mongrel ()
2593 {
2594   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2595   if eval \${$3+:} false; then :
2596   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2597 $as_echo_n "checking for $2... " >&6; }
2598 if eval \${$3+:} false; then :
2599   $as_echo_n "(cached) " >&6
2600 fi
2601 eval ac_res=\$$3
2602                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2603 $as_echo "$ac_res" >&6; }
2604 else
2605   # Is the header compilable?
2606 { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
2607 $as_echo_n "checking $2 usability... " >&6; }
2608 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2609 /* end confdefs.h.  */
2610 $4
2611 #include <$2>
2612 _ACEOF
2613 if ac_fn_cxx_try_compile "$LINENO"; then :
2614   ac_header_compiler=yes
2615 else
2616   ac_header_compiler=no
2617 fi
2618 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2619 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
2620 $as_echo "$ac_header_compiler" >&6; }
2621 
2622 # Is the header present?
2623 { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
2624 $as_echo_n "checking $2 presence... " >&6; }
2625 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2626 /* end confdefs.h.  */
2627 #include <$2>
2628 _ACEOF
2629 if ac_fn_cxx_try_cpp "$LINENO"; then :
2630   ac_header_preproc=yes
2631 else
2632   ac_header_preproc=no
2633 fi
2634 rm -f conftest.err conftest.i conftest.$ac_ext
2635 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
2636 $as_echo "$ac_header_preproc" >&6; }
2637 
2638 # So?  What about this header?
2639 case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in #((
2640   yes:no: )
2641     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
2642 $as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
2643     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
2644 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
2645     ;;
2646   no:yes:* )
2647     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
2648 $as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
2649     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     check for missing prerequisite headers?" >&5
2650 $as_echo "$as_me: WARNING: $2:     check for missing prerequisite headers?" >&2;}
2651     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
2652 $as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
2653     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&5
2654 $as_echo "$as_me: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&2;}
2655     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
2656 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
2657 ( $as_echo "## ----------------------------------------- ##
2658 ## Report this to build-dev@openjdk.java.net ##
2659 ## ----------------------------------------- ##"
2660      ) | sed "s/^/$as_me: WARNING:     /" >&2
2661     ;;
2662 esac
2663   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2664 $as_echo_n "checking for $2... " >&6; }
2665 if eval \${$3+:} false; then :
2666   $as_echo_n "(cached) " >&6
2667 else
2668   eval "$3=\$ac_header_compiler"
2669 fi
2670 eval ac_res=\$$3
2671                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2672 $as_echo "$ac_res" >&6; }
2673 fi
2674   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2675 
2676 } # ac_fn_cxx_check_header_mongrel
2677 
2678 # ac_fn_cxx_try_run LINENO
2679 # ------------------------
2680 # Try to link conftest.$ac_ext, and return whether this succeeded. Assumes
2681 # that executables *can* be run.
2682 ac_fn_cxx_try_run ()
2683 {
2684   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2685   if { { ac_try="$ac_link"
2686 case "(($ac_try" in
2687   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2688   *) ac_try_echo=$ac_try;;
2689 esac
2690 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2691 $as_echo "$ac_try_echo"; } >&5
2692   (eval "$ac_link") 2>&5
2693   ac_status=$?
2694   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2695   test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'
2696   { { case "(($ac_try" in
2697   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2698   *) ac_try_echo=$ac_try;;
2699 esac
2700 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2701 $as_echo "$ac_try_echo"; } >&5
2702   (eval "$ac_try") 2>&5
2703   ac_status=$?
2704   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2705   test $ac_status = 0; }; }; then :
2706   ac_retval=0
2707 else
2708   $as_echo "$as_me: program exited with status $ac_status" >&5
2709        $as_echo "$as_me: failed program was:" >&5
2710 sed 's/^/| /' conftest.$ac_ext >&5
2711 
2712        ac_retval=$ac_status
2713 fi
2714   rm -rf conftest.dSYM conftest_ipa8_conftest.oo
2715   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2716   as_fn_set_status $ac_retval
2717 
2718 } # ac_fn_cxx_try_run
2719 
2720 # ac_fn_cxx_check_header_compile LINENO HEADER VAR INCLUDES
2721 # ---------------------------------------------------------
2722 # Tests whether HEADER exists and can be compiled using the include files in
2723 # INCLUDES, setting the cache variable VAR accordingly.
2724 ac_fn_cxx_check_header_compile ()
2725 {
2726   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2727   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2728 $as_echo_n "checking for $2... " >&6; }
2729 if eval \${$3+:} false; then :
2730   $as_echo_n "(cached) " >&6
2731 else
2732   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2733 /* end confdefs.h.  */
2734 $4
2735 #include <$2>
2736 _ACEOF
2737 if ac_fn_cxx_try_compile "$LINENO"; then :
2738   eval "$3=yes"
2739 else
2740   eval "$3=no"
2741 fi
2742 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2743 fi
2744 eval ac_res=\$$3
2745                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2746 $as_echo "$ac_res" >&6; }
2747   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2748 
2749 } # ac_fn_cxx_check_header_compile
2750 
2751 # ac_fn_cxx_compute_int LINENO EXPR VAR INCLUDES
2752 # ----------------------------------------------
2753 # Tries to find the compile-time value of EXPR in a program that includes
2754 # INCLUDES, setting VAR accordingly. Returns whether the value could be
2755 # computed
2756 ac_fn_cxx_compute_int ()
2757 {
2758   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2759   if test "$cross_compiling" = yes; then
2760     # Depending upon the size, compute the lo and hi bounds.
2761 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2762 /* end confdefs.h.  */
2763 $4
2764 int
2765 main ()
2766 {
2767 static int test_array [1 - 2 * !(($2) >= 0)];
2768 test_array [0] = 0;
2769 return test_array [0];
2770 
2771   ;
2772   return 0;
2773 }
2774 _ACEOF
2775 if ac_fn_cxx_try_compile "$LINENO"; then :
2776   ac_lo=0 ac_mid=0
2777   while :; do
2778     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2779 /* end confdefs.h.  */
2780 $4
2781 int
2782 main ()
2783 {
2784 static int test_array [1 - 2 * !(($2) <= $ac_mid)];
2785 test_array [0] = 0;
2786 return test_array [0];
2787 
2788   ;
2789   return 0;
2790 }
2791 _ACEOF
2792 if ac_fn_cxx_try_compile "$LINENO"; then :
2793   ac_hi=$ac_mid; break
2794 else
2795   as_fn_arith $ac_mid + 1 && ac_lo=$as_val
2796                         if test $ac_lo -le $ac_mid; then
2797                           ac_lo= ac_hi=
2798                           break
2799                         fi
2800                         as_fn_arith 2 '*' $ac_mid + 1 && ac_mid=$as_val
2801 fi
2802 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2803   done
2804 else
2805   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2806 /* end confdefs.h.  */
2807 $4
2808 int
2809 main ()
2810 {
2811 static int test_array [1 - 2 * !(($2) < 0)];
2812 test_array [0] = 0;
2813 return test_array [0];
2814 
2815   ;
2816   return 0;
2817 }
2818 _ACEOF
2819 if ac_fn_cxx_try_compile "$LINENO"; then :
2820   ac_hi=-1 ac_mid=-1
2821   while :; do
2822     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2823 /* end confdefs.h.  */
2824 $4
2825 int
2826 main ()
2827 {
2828 static int test_array [1 - 2 * !(($2) >= $ac_mid)];
2829 test_array [0] = 0;
2830 return test_array [0];
2831 
2832   ;
2833   return 0;
2834 }
2835 _ACEOF
2836 if ac_fn_cxx_try_compile "$LINENO"; then :
2837   ac_lo=$ac_mid; break
2838 else
2839   as_fn_arith '(' $ac_mid ')' - 1 && ac_hi=$as_val
2840                         if test $ac_mid -le $ac_hi; then
2841                           ac_lo= ac_hi=
2842                           break
2843                         fi
2844                         as_fn_arith 2 '*' $ac_mid && ac_mid=$as_val
2845 fi
2846 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2847   done
2848 else
2849   ac_lo= ac_hi=
2850 fi
2851 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2852 fi
2853 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2854 # Binary search between lo and hi bounds.
2855 while test "x$ac_lo" != "x$ac_hi"; do
2856   as_fn_arith '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo && ac_mid=$as_val
2857   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2858 /* end confdefs.h.  */
2859 $4
2860 int
2861 main ()
2862 {
2863 static int test_array [1 - 2 * !(($2) <= $ac_mid)];
2864 test_array [0] = 0;
2865 return test_array [0];
2866 
2867   ;
2868   return 0;
2869 }
2870 _ACEOF
2871 if ac_fn_cxx_try_compile "$LINENO"; then :
2872   ac_hi=$ac_mid
2873 else
2874   as_fn_arith '(' $ac_mid ')' + 1 && ac_lo=$as_val
2875 fi
2876 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2877 done
2878 case $ac_lo in #((
2879 ?*) eval "$3=\$ac_lo"; ac_retval=0 ;;
2880 '') ac_retval=1 ;;
2881 esac
2882   else
2883     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2884 /* end confdefs.h.  */
2885 $4
2886 static long int longval () { return $2; }
2887 static unsigned long int ulongval () { return $2; }
2888 #include <stdio.h>
2889 #include <stdlib.h>
2890 int
2891 main ()
2892 {
2893 
2894   FILE *f = fopen ("conftest.val", "w");
2895   if (! f)
2896     return 1;
2897   if (($2) < 0)
2898     {
2899       long int i = longval ();
2900       if (i != ($2))
2901         return 1;
2902       fprintf (f, "%ld", i);
2903     }
2904   else
2905     {
2906       unsigned long int i = ulongval ();
2907       if (i != ($2))
2908         return 1;
2909       fprintf (f, "%lu", i);
2910     }
2911   /* Do not output a trailing newline, as this causes \r\n confusion
2912      on some platforms.  */
2913   return ferror (f) || fclose (f) != 0;
2914 
2915   ;
2916   return 0;
2917 }
2918 _ACEOF
2919 if ac_fn_cxx_try_run "$LINENO"; then :
2920   echo >>conftest.val; read $3 <conftest.val; ac_retval=0
2921 else
2922   ac_retval=1
2923 fi
2924 rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
2925   conftest.$ac_objext conftest.beam conftest.$ac_ext
2926 rm -f conftest.val
2927 
2928   fi
2929   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2930   as_fn_set_status $ac_retval
2931 
2932 } # ac_fn_cxx_compute_int
2933 
2934 # ac_fn_cxx_try_link LINENO
2935 # -------------------------
2936 # Try to link conftest.$ac_ext, and return whether this succeeded.
2937 ac_fn_cxx_try_link ()
2938 {
2939   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2940   rm -f conftest.$ac_objext conftest$ac_exeext
2941   if { { ac_try="$ac_link"
2942 case "(($ac_try" in
2943   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2944   *) ac_try_echo=$ac_try;;
2945 esac
2946 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2947 $as_echo "$ac_try_echo"; } >&5
2948   (eval "$ac_link") 2>conftest.err
2949   ac_status=$?
2950   if test -s conftest.err; then
2951     grep -v '^ *+' conftest.err >conftest.er1
2952     cat conftest.er1 >&5
2953     mv -f conftest.er1 conftest.err
2954   fi
2955   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2956   test $ac_status = 0; } && {
2957          test -z "$ac_cxx_werror_flag" ||
2958          test ! -s conftest.err
2959        } && test -s conftest$ac_exeext && {
2960          test "$cross_compiling" = yes ||
2961          test -x conftest$ac_exeext
2962        }; then :
2963   ac_retval=0
2964 else
2965   $as_echo "$as_me: failed program was:" >&5
2966 sed 's/^/| /' conftest.$ac_ext >&5
2967 
2968         ac_retval=1
2969 fi
2970   # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
2971   # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
2972   # interfere with the next link command; also delete a directory that is
2973   # left behind by Apple's compiler.  We do this before executing the actions.
2974   rm -rf conftest.dSYM conftest_ipa8_conftest.oo
2975   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2976   as_fn_set_status $ac_retval
2977 
2978 } # ac_fn_cxx_try_link
2979 
2980 # ac_fn_cxx_check_func LINENO FUNC VAR
2981 # ------------------------------------
2982 # Tests whether FUNC exists, setting the cache variable VAR accordingly
2983 ac_fn_cxx_check_func ()
2984 {
2985   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2986   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2987 $as_echo_n "checking for $2... " >&6; }
2988 if eval \${$3+:} false; then :
2989   $as_echo_n "(cached) " >&6
2990 else
2991   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2992 /* end confdefs.h.  */
2993 /* Define $2 to an innocuous variant, in case <limits.h> declares $2.
2994    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
2995 #define $2 innocuous_$2
2996 
2997 /* System header to define __stub macros and hopefully few prototypes,
2998     which can conflict with char $2 (); below.
2999     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
3000     <limits.h> exists even on freestanding compilers.  */
3001 
3002 #ifdef __STDC__
3003 # include <limits.h>
3004 #else
3005 # include <assert.h>
3006 #endif
3007 
3008 #undef $2
3009 
3010 /* Override any GCC internal prototype to avoid an error.
3011    Use char because int might match the return type of a GCC
3012    builtin and then its argument prototype would still apply.  */
3013 #ifdef __cplusplus
3014 extern "C"
3015 #endif
3016 char $2 ();
3017 /* The GNU C library defines this for functions which it implements
3018     to always fail with ENOSYS.  Some functions are actually named
3019     something starting with __ and the normal name is an alias.  */
3020 #if defined __stub_$2 || defined __stub___$2
3021 choke me
3022 #endif
3023 
3024 int
3025 main ()
3026 {
3027 return $2 ();
3028   ;
3029   return 0;
3030 }
3031 _ACEOF
3032 if ac_fn_cxx_try_link "$LINENO"; then :
3033   eval "$3=yes"
3034 else
3035   eval "$3=no"
3036 fi
3037 rm -f core conftest.err conftest.$ac_objext \
3038     conftest$ac_exeext conftest.$ac_ext
3039 fi
3040 eval ac_res=\$$3
3041                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
3042 $as_echo "$ac_res" >&6; }
3043   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
3044 
3045 } # ac_fn_cxx_check_func
3046 
3047 # ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES
3048 # -------------------------------------------------------
3049 # Tests whether HEADER exists and can be compiled using the include files in
3050 # INCLUDES, setting the cache variable VAR accordingly.
3051 ac_fn_c_check_header_compile ()
3052 {
3053   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
3054   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
3055 $as_echo_n "checking for $2... " >&6; }
3056 if eval \${$3+:} false; then :
3057   $as_echo_n "(cached) " >&6
3058 else
3059   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3060 /* end confdefs.h.  */
3061 $4
3062 #include <$2>
3063 _ACEOF
3064 if ac_fn_c_try_compile "$LINENO"; then :
3065   eval "$3=yes"
3066 else
3067   eval "$3=no"
3068 fi
3069 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3070 fi
3071 eval ac_res=\$$3
3072                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
3073 $as_echo "$ac_res" >&6; }
3074   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
3075 
3076 } # ac_fn_c_check_header_compile
3077 cat >config.log <<_ACEOF
3078 This file contains any messages produced by compilers while
3079 running configure, to aid debugging if configure makes a mistake.
3080 
3081 It was created by OpenJDK $as_me jdk9, which was
3082 generated by GNU Autoconf 2.69.  Invocation command line was
3083 
3084   $ $0 $@
3085 
3086 _ACEOF
3087 exec 5>>config.log
3088 {
3089 cat <<_ASUNAME
3090 ## --------- ##
3091 ## Platform. ##
3092 ## --------- ##
3093 
3094 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
3095 uname -m = `(uname -m) 2>/dev/null || echo unknown`
3096 uname -r = `(uname -r) 2>/dev/null || echo unknown`
3097 uname -s = `(uname -s) 2>/dev/null || echo unknown`
3098 uname -v = `(uname -v) 2>/dev/null || echo unknown`
3099 
3100 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
3101 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
3102 
3103 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
3104 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
3105 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
3106 /usr/bin/hostinfo      = `(/usr/bin/hostinfo) 2>/dev/null      || echo unknown`
3107 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
3108 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
3109 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
3110 
3111 _ASUNAME
3112 
3113 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3114 for as_dir in $PATH
3115 do
3116   IFS=$as_save_IFS
3117   test -z "$as_dir" && as_dir=.
3118     $as_echo "PATH: $as_dir"
3119   done
3120 IFS=$as_save_IFS
3121 
3122 } >&5
3123 
3124 cat >&5 <<_ACEOF
3125 
3126 
3127 ## ----------- ##
3128 ## Core tests. ##
3129 ## ----------- ##
3130 
3131 _ACEOF
3132 
3133 
3134 # Keep a trace of the command line.
3135 # Strip out --no-create and --no-recursion so they do not pile up.
3136 # Strip out --silent because we don't want to record it for future runs.
3137 # Also quote any args containing shell meta-characters.
3138 # Make two passes to allow for proper duplicate-argument suppression.
3139 ac_configure_args=
3140 ac_configure_args0=
3141 ac_configure_args1=
3142 ac_must_keep_next=false
3143 for ac_pass in 1 2
3144 do
3145   for ac_arg
3146   do
3147     case $ac_arg in
3148     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
3149     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
3150     | -silent | --silent | --silen | --sile | --sil)
3151       continue ;;
3152     *\'*)
3153       ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
3154     esac
3155     case $ac_pass in
3156     1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;
3157     2)
3158       as_fn_append ac_configure_args1 " '$ac_arg'"
3159       if test $ac_must_keep_next = true; then
3160         ac_must_keep_next=false # Got value, back to normal.
3161       else
3162         case $ac_arg in
3163           *=* | --config-cache | -C | -disable-* | --disable-* \
3164           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
3165           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
3166           | -with-* | --with-* | -without-* | --without-* | --x)
3167             case "$ac_configure_args0 " in
3168               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
3169             esac
3170             ;;
3171           -* ) ac_must_keep_next=true ;;
3172         esac
3173       fi
3174       as_fn_append ac_configure_args " '$ac_arg'"
3175       ;;
3176     esac
3177   done
3178 done
3179 { ac_configure_args0=; unset ac_configure_args0;}
3180 { ac_configure_args1=; unset ac_configure_args1;}
3181 
3182 # When interrupted or exit'd, cleanup temporary files, and complete
3183 # config.log.  We remove comments because anyway the quotes in there
3184 # would cause problems or look ugly.
3185 # WARNING: Use '\'' to represent an apostrophe within the trap.
3186 # WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.
3187 trap 'exit_status=$?
3188   # Save into config.log some information that might help in debugging.
3189   {
3190     echo
3191 
3192     $as_echo "## ---------------- ##
3193 ## Cache variables. ##
3194 ## ---------------- ##"
3195     echo
3196     # The following way of writing the cache mishandles newlines in values,
3197 (
3198   for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do
3199     eval ac_val=\$$ac_var
3200     case $ac_val in #(
3201     *${as_nl}*)
3202       case $ac_var in #(
3203       *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
3204 $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
3205       esac
3206       case $ac_var in #(
3207       _ | IFS | as_nl) ;; #(
3208       BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
3209       *) { eval $ac_var=; unset $ac_var;} ;;
3210       esac ;;
3211     esac
3212   done
3213   (set) 2>&1 |
3214     case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #(
3215     *${as_nl}ac_space=\ *)
3216       sed -n \
3217         "s/'\''/'\''\\\\'\'''\''/g;
3218           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p"
3219       ;; #(
3220     *)
3221       sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
3222       ;;
3223     esac |
3224     sort
3225 )
3226     echo
3227 
3228     $as_echo "## ----------------- ##
3229 ## Output variables. ##
3230 ## ----------------- ##"
3231     echo
3232     for ac_var in $ac_subst_vars
3233     do
3234       eval ac_val=\$$ac_var
3235       case $ac_val in
3236       *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
3237       esac
3238       $as_echo "$ac_var='\''$ac_val'\''"
3239     done | sort
3240     echo
3241 
3242     if test -n "$ac_subst_files"; then
3243       $as_echo "## ------------------- ##
3244 ## File substitutions. ##
3245 ## ------------------- ##"
3246       echo
3247       for ac_var in $ac_subst_files
3248       do
3249         eval ac_val=\$$ac_var
3250         case $ac_val in
3251         *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
3252         esac
3253         $as_echo "$ac_var='\''$ac_val'\''"
3254       done | sort
3255       echo
3256     fi
3257 
3258     if test -s confdefs.h; then
3259       $as_echo "## ----------- ##
3260 ## confdefs.h. ##
3261 ## ----------- ##"
3262       echo
3263       cat confdefs.h
3264       echo
3265     fi
3266     test "$ac_signal" != 0 &&
3267       $as_echo "$as_me: caught signal $ac_signal"
3268     $as_echo "$as_me: exit $exit_status"
3269   } >&5
3270   rm -f core *.core core.conftest.* &&
3271     rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
3272     exit $exit_status
3273 ' 0
3274 for ac_signal in 1 2 13 15; do
3275   trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal
3276 done
3277 ac_signal=0
3278 
3279 # confdefs.h avoids OS command line length limits that DEFS can exceed.
3280 rm -f -r conftest* confdefs.h
3281 
3282 $as_echo "/* confdefs.h */" > confdefs.h
3283 
3284 # Predefined preprocessor variables.
3285 
3286 cat >>confdefs.h <<_ACEOF
3287 #define PACKAGE_NAME "$PACKAGE_NAME"
3288 _ACEOF
3289 
3290 cat >>confdefs.h <<_ACEOF
3291 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
3292 _ACEOF
3293 
3294 cat >>confdefs.h <<_ACEOF
3295 #define PACKAGE_VERSION "$PACKAGE_VERSION"
3296 _ACEOF
3297 
3298 cat >>confdefs.h <<_ACEOF
3299 #define PACKAGE_STRING "$PACKAGE_STRING"
3300 _ACEOF
3301 
3302 cat >>confdefs.h <<_ACEOF
3303 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
3304 _ACEOF
3305 
3306 cat >>confdefs.h <<_ACEOF
3307 #define PACKAGE_URL "$PACKAGE_URL"
3308 _ACEOF
3309 
3310 
3311 # Let the site file select an alternate cache file if it wants to.
3312 # Prefer an explicitly selected file to automatically selected ones.
3313 ac_site_file1=NONE
3314 ac_site_file2=NONE
3315 if test -n "$CONFIG_SITE"; then
3316   # We do not want a PATH search for config.site.
3317   case $CONFIG_SITE in #((
3318     -*)  ac_site_file1=./$CONFIG_SITE;;
3319     */*) ac_site_file1=$CONFIG_SITE;;
3320     *)   ac_site_file1=./$CONFIG_SITE;;
3321   esac
3322 elif test "x$prefix" != xNONE; then
3323   ac_site_file1=$prefix/share/config.site
3324   ac_site_file2=$prefix/etc/config.site
3325 else
3326   ac_site_file1=$ac_default_prefix/share/config.site
3327   ac_site_file2=$ac_default_prefix/etc/config.site
3328 fi
3329 for ac_site_file in "$ac_site_file1" "$ac_site_file2"
3330 do
3331   test "x$ac_site_file" = xNONE && continue
3332   if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then
3333     { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
3334 $as_echo "$as_me: loading site script $ac_site_file" >&6;}
3335     sed 's/^/| /' "$ac_site_file" >&5
3336     . "$ac_site_file" \
3337       || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3338 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3339 as_fn_error $? "failed to load site script $ac_site_file
3340 See \`config.log' for more details" "$LINENO" 5; }
3341   fi
3342 done
3343 
3344 if test -r "$cache_file"; then
3345   # Some versions of bash will fail to source /dev/null (special files
3346   # actually), so we avoid doing that.  DJGPP emulates it as a regular file.
3347   if test /dev/null != "$cache_file" && test -f "$cache_file"; then
3348     { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
3349 $as_echo "$as_me: loading cache $cache_file" >&6;}
3350     case $cache_file in
3351       [\\/]* | ?:[\\/]* ) . "$cache_file";;
3352       *)                      . "./$cache_file";;
3353     esac
3354   fi
3355 else
3356   { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
3357 $as_echo "$as_me: creating cache $cache_file" >&6;}
3358   >$cache_file
3359 fi
3360 
3361 # Check that the precious variables saved in the cache have kept the same
3362 # value.
3363 ac_cache_corrupted=false
3364 for ac_var in $ac_precious_vars; do
3365   eval ac_old_set=\$ac_cv_env_${ac_var}_set
3366   eval ac_new_set=\$ac_env_${ac_var}_set
3367   eval ac_old_val=\$ac_cv_env_${ac_var}_value
3368   eval ac_new_val=\$ac_env_${ac_var}_value
3369   case $ac_old_set,$ac_new_set in
3370     set,)
3371       { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
3372 $as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
3373       ac_cache_corrupted=: ;;
3374     ,set)
3375       { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5
3376 $as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
3377       ac_cache_corrupted=: ;;
3378     ,);;
3379     *)
3380       if test "x$ac_old_val" != "x$ac_new_val"; then
3381         # differences in whitespace do not lead to failure.
3382         ac_old_val_w=`echo x $ac_old_val`
3383         ac_new_val_w=`echo x $ac_new_val`
3384         if test "$ac_old_val_w" != "$ac_new_val_w"; then
3385           { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5
3386 $as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
3387           ac_cache_corrupted=:
3388         else
3389           { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
3390 $as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
3391           eval $ac_var=\$ac_old_val
3392         fi
3393         { $as_echo "$as_me:${as_lineno-$LINENO}:   former value:  \`$ac_old_val'" >&5
3394 $as_echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
3395         { $as_echo "$as_me:${as_lineno-$LINENO}:   current value: \`$ac_new_val'" >&5
3396 $as_echo "$as_me:   current value: \`$ac_new_val'" >&2;}
3397       fi;;
3398   esac
3399   # Pass precious variables to config.status.
3400   if test "$ac_new_set" = set; then
3401     case $ac_new_val in
3402     *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
3403     *) ac_arg=$ac_var=$ac_new_val ;;
3404     esac
3405     case " $ac_configure_args " in
3406       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
3407       *) as_fn_append ac_configure_args " '$ac_arg'" ;;
3408     esac
3409   fi
3410 done
3411 if $ac_cache_corrupted; then
3412   { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3413 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3414   { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
3415 $as_echo "$as_me: error: changes in the environment can compromise the build" >&2;}
3416   as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5
3417 fi
3418 ## -------------------- ##
3419 ## Main body of script. ##
3420 ## -------------------- ##
3421 
3422 ac_ext=c
3423 ac_cpp='$CPP $CPPFLAGS'
3424 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3425 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3426 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3427 
3428 
3429 
3430 ac_aux_dir=
3431 for ac_dir in $TOPDIR/common/autoconf/build-aux "$srcdir"/$TOPDIR/common/autoconf/build-aux; do
3432   if test -f "$ac_dir/install-sh"; then
3433     ac_aux_dir=$ac_dir
3434     ac_install_sh="$ac_aux_dir/install-sh -c"
3435     break
3436   elif test -f "$ac_dir/install.sh"; then
3437     ac_aux_dir=$ac_dir
3438     ac_install_sh="$ac_aux_dir/install.sh -c"
3439     break
3440   elif test -f "$ac_dir/shtool"; then
3441     ac_aux_dir=$ac_dir
3442     ac_install_sh="$ac_aux_dir/shtool install -c"
3443     break
3444   fi
3445 done
3446 if test -z "$ac_aux_dir"; then
3447   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
3448 fi
3449 
3450 # These three variables are undocumented and unsupported,
3451 # and are intended to be withdrawn in a future Autoconf release.
3452 # They can cause serious problems if a builder's source tree is in a directory
3453 # whose full name contains unusual characters.
3454 ac_config_guess="$SHELL $ac_aux_dir/config.guess"  # Please don't use this var.
3455 ac_config_sub="$SHELL $ac_aux_dir/config.sub"  # Please don't use this var.
3456 ac_configure="$SHELL $ac_aux_dir/configure"  # Please don't use this var.
3457 
3458 
3459 # pkg.m4 - Macros to locate and utilise pkg-config.            -*- Autoconf -*-
3460 
3461 #
3462 # Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
3463 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3464 #
3465 # This code is free software; you can redistribute it and/or modify it
3466 # under the terms of the GNU General Public License version 2 only, as
3467 # published by the Free Software Foundation.  Oracle designates this
3468 # particular file as subject to the "Classpath" exception as provided
3469 # by Oracle in the LICENSE file that accompanied this code.
3470 #
3471 # This code is distributed in the hope that it will be useful, but WITHOUT
3472 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3473 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3474 # version 2 for more details (a copy is included in the LICENSE file that
3475 # accompanied this code).
3476 #
3477 # You should have received a copy of the GNU General Public License version
3478 # 2 along with this work; if not, write to the Free Software Foundation,
3479 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3480 #
3481 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3482 # or visit www.oracle.com if you need additional information or have any
3483 # questions.
3484 #
3485 
3486 #
3487 # Copyright © 2004 Scott James Remnant <scott@netsplit.com>.
3488 #
3489 # This program is free software; you can redistribute it and/or modify
3490 # it under the terms of the GNU General Public License as published by
3491 # the Free Software Foundation; either version 2 of the License, or
3492 # (at your option) any later version.
3493 #
3494 # This program is distributed in the hope that it will be useful, but
3495 # WITHOUT ANY WARRANTY; without even the implied warranty of
3496 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
3497 # General Public License for more details.
3498 #
3499 # You should have received a copy of the GNU General Public License
3500 # along with this program; if not, write to the Free Software
3501 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
3502 #
3503 # As a special exception to the GNU General Public License, if you
3504 # distribute this file as part of a program that contains a
3505 # configuration script generated by Autoconf, you may include it under
3506 # the same distribution terms that you use for the rest of that program.
3507 
3508 # PKG_PROG_PKG_CONFIG([MIN-VERSION])
3509 # ----------------------------------
3510 # PKG_PROG_PKG_CONFIG
3511 
3512 # PKG_CHECK_EXISTS(MODULES, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
3513 #
3514 # Check to see whether a particular set of modules exists.  Similar
3515 # to PKG_CHECK_MODULES(), but does not set variables or print errors.
3516 #
3517 #
3518 # Similar to PKG_CHECK_MODULES, make sure that the first instance of
3519 # this or PKG_CHECK_MODULES is called, or make sure to call
3520 # PKG_CHECK_EXISTS manually
3521 # --------------------------------------------------------------
3522 
3523 
3524 
3525 # _PKG_CONFIG([VARIABLE], [COMMAND], [MODULES])
3526 # ---------------------------------------------
3527 # _PKG_CONFIG
3528 
3529 # _PKG_SHORT_ERRORS_SUPPORTED
3530 # -----------------------------
3531 # _PKG_SHORT_ERRORS_SUPPORTED
3532 
3533 
3534 # PKG_CHECK_MODULES(VARIABLE-PREFIX, MODULES, [ACTION-IF-FOUND],
3535 # [ACTION-IF-NOT-FOUND])
3536 #
3537 #
3538 # Note that if there is a possibility the first call to
3539 # PKG_CHECK_MODULES might not happen, you should be sure to include an
3540 # explicit call to PKG_PROG_PKG_CONFIG in your configure.ac
3541 #
3542 #
3543 # --------------------------------------------------------------
3544 # PKG_CHECK_MODULES
3545 
3546 
3547 # Include these first...
3548 #
3549 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
3550 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3551 #
3552 # This code is free software; you can redistribute it and/or modify it
3553 # under the terms of the GNU General Public License version 2 only, as
3554 # published by the Free Software Foundation.  Oracle designates this
3555 # particular file as subject to the "Classpath" exception as provided
3556 # by Oracle in the LICENSE file that accompanied this code.
3557 #
3558 # This code is distributed in the hope that it will be useful, but WITHOUT
3559 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3560 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3561 # version 2 for more details (a copy is included in the LICENSE file that
3562 # accompanied this code).
3563 #
3564 # You should have received a copy of the GNU General Public License version
3565 # 2 along with this work; if not, write to the Free Software Foundation,
3566 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3567 #
3568 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3569 # or visit www.oracle.com if you need additional information or have any
3570 # questions.
3571 #
3572 
3573 # Create a function/macro that takes a series of named arguments. The call is
3574 # similar to AC_DEFUN, but the setup of the function looks like this:
3575 # BASIC_DEFUN_NAMED([MYFUNC], [FOO *BAR], [$@], [
3576 # ... do something
3577 #   AC_MSG_NOTICE([Value of BAR is ARG_BAR])
3578 # ])
3579 # A star (*) in front of a named argument means that it is required and it's
3580 # presence will be verified. To pass e.g. the first value as a normal indexed
3581 # argument, use [m4_shift($@)] as the third argument instead of [$@]. These
3582 # arguments are referenced in the function by their name prefixed by ARG_, e.g.
3583 # "ARG_FOO".
3584 #
3585 # The generated function can be called like this:
3586 # MYFUNC(FOO: [foo-val],
3587 #     BAR: [
3588 #         $ECHO hello world
3589 #     ])
3590 # Note that the argument value must start on the same line as the argument name.
3591 #
3592 # Argument 1: Name of the function to define
3593 # Argument 2: List of legal named arguments, with a * prefix for required arguments
3594 # Argument 3: Argument array to treat as named, typically $@
3595 # Argument 4: The main function body
3596 
3597 
3598 # Test if $1 is a valid argument to $3 (often is $JAVA passed as $3)
3599 # If so, then append $1 to $2 \
3600 # Also set JVM_ARG_OK to true/false depending on outcome.
3601 
3602 
3603 # Appends a string to a path variable, only adding the : when needed.
3604 
3605 
3606 # Prepends a string to a path variable, only adding the : when needed.
3607 
3608 
3609 # This will make sure the given variable points to a full and proper
3610 # path. This means:
3611 # 1) There will be no spaces in the path. On unix platforms,
3612 #    spaces in the path will result in an error. On Windows,
3613 #    the path will be rewritten using short-style to be space-free.
3614 # 2) The path will be absolute, and it will be in unix-style (on
3615 #     cygwin).
3616 # $1: The name of the variable to fix
3617 
3618 
3619 # This will make sure the given variable points to a executable
3620 # with a full and proper path. This means:
3621 # 1) There will be no spaces in the path. On unix platforms,
3622 #    spaces in the path will result in an error. On Windows,
3623 #    the path will be rewritten using short-style to be space-free.
3624 # 2) The path will be absolute, and it will be in unix-style (on
3625 #     cygwin).
3626 # Any arguments given to the executable is preserved.
3627 # If the input variable does not have a directory specification, then
3628 # it need to be in the PATH.
3629 # $1: The name of the variable to fix
3630 
3631 
3632 
3633 
3634 # Register a --with argument but mark it as deprecated
3635 # $1: The name of the with argument to deprecate, not including --with-
3636 
3637 
3638 # Register a --enable argument but mark it as deprecated
3639 # $1: The name of the with argument to deprecate, not including --enable-
3640 # $2: The name of the argument to deprecate, in shell variable style (i.e. with _ instead of -)
3641 # $3: Messages to user.
3642 
3643 
3644 
3645 
3646 # Test that variable $1 denoting a program is not empty. If empty, exit with an error.
3647 # $1: variable to check
3648 
3649 
3650 # Check that there are no unprocessed overridden variables left.
3651 # If so, they are an incorrect argument and we will exit with an error.
3652 
3653 
3654 # Setup a tool for the given variable. If correctly specified by the user,
3655 # use that value, otherwise search for the tool using the supplied code snippet.
3656 # $1: variable to set
3657 # $2: code snippet to call to look for the tool
3658 # $3: code snippet to call if variable was used to find tool
3659 
3660 
3661 # Call BASIC_SETUP_TOOL with AC_PATH_PROGS to locate the tool
3662 # $1: variable to set
3663 # $2: executable name (or list of names) to look for
3664 
3665 
3666 # Call BASIC_SETUP_TOOL with AC_CHECK_TOOLS to locate the tool
3667 # $1: variable to set
3668 # $2: executable name (or list of names) to look for
3669 
3670 
3671 # Like BASIC_PATH_PROGS but fails if no tool was found.
3672 # $1: variable to set
3673 # $2: executable name (or list of names) to look for
3674 
3675 
3676 # Like BASIC_SETUP_TOOL but fails if no tool was found.
3677 # $1: variable to set
3678 # $2: autoconf macro to call to look for the special tool
3679 
3680 
3681 # Setup the most fundamental tools that relies on not much else to set up,
3682 # but is used by much of the early bootstrap code.
3683 
3684 
3685 # Setup basic configuration paths, and platform-specific stuff related to PATHs.
3686 
3687 
3688 # Evaluates platform specific overrides for devkit variables.
3689 # $1: Name of variable
3690 
3691 
3692 
3693 
3694 
3695 
3696 #%%% Simple tools %%%
3697 
3698 # Check if we have found a usable version of make
3699 # $1: the path to a potential make binary (or empty)
3700 # $2: the description on how we found this
3701 
3702 
3703 
3704 
3705 # Goes looking for a usable version of GNU make.
3706 
3707 
3708 
3709 
3710 
3711 
3712 
3713 
3714 # Check if build directory is on local disk. If not possible to determine,
3715 # we prefer to claim it's local.
3716 # Argument 1: directory to test
3717 # Argument 2: what to do if it is on local disk
3718 # Argument 3: what to do otherwise (remote disk or failure)
3719 
3720 
3721 # Check that source files have basic read permissions set. This might
3722 # not be the case in cygwin in certain conditions.
3723 
3724 
3725 
3726 
3727 # Check for support for specific options in bash
3728 
3729 
3730 ################################################################################
3731 #
3732 # Default make target
3733 #
3734 
3735 
3736 # Code to run after AC_OUTPUT
3737 
3738 
3739 #
3740 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
3741 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3742 #
3743 # This code is free software; you can redistribute it and/or modify it
3744 # under the terms of the GNU General Public License version 2 only, as
3745 # published by the Free Software Foundation.  Oracle designates this
3746 # particular file as subject to the "Classpath" exception as provided
3747 # by Oracle in the LICENSE file that accompanied this code.
3748 #
3749 # This code is distributed in the hope that it will be useful, but WITHOUT
3750 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3751 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3752 # version 2 for more details (a copy is included in the LICENSE file that
3753 # accompanied this code).
3754 #
3755 # You should have received a copy of the GNU General Public License version
3756 # 2 along with this work; if not, write to the Free Software Foundation,
3757 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3758 #
3759 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3760 # or visit www.oracle.com if you need additional information or have any
3761 # questions.
3762 #
3763 
3764 
3765 
3766 
3767 
3768 # Helper function which possibly converts a path using DOS-style short mode.
3769 # If so, the updated path is stored in $new_path.
3770 # $1: The path to check
3771 
3772 
3773 # Helper function which possibly converts a path using DOS-style short mode.
3774 # If so, the updated path is stored in $new_path.
3775 # $1: The path to check
3776 
3777 
3778 # FIXME: The BASIC_FIXUP_*_CYGWIN/MSYS is most likely too convoluted
3779 # and could probably be heavily simplified. However, all changes in this
3780 # area tend to need lot of testing in different scenarios, and in lack of
3781 # proper unit testing, cleaning this up has not been deemed worth the effort
3782 # at the moment.
3783 
3784 
3785 
3786 
3787 
3788 
3789 
3790 
3791 
3792 # Setup basic configuration paths, and platform-specific stuff related to PATHs.
3793 
3794 
3795 
3796 
3797 # ... then the rest
3798 #
3799 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
3800 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3801 #
3802 # This code is free software; you can redistribute it and/or modify it
3803 # under the terms of the GNU General Public License version 2 only, as
3804 # published by the Free Software Foundation.  Oracle designates this
3805 # particular file as subject to the "Classpath" exception as provided
3806 # by Oracle in the LICENSE file that accompanied this code.
3807 #
3808 # This code is distributed in the hope that it will be useful, but WITHOUT
3809 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3810 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3811 # version 2 for more details (a copy is included in the LICENSE file that
3812 # accompanied this code).
3813 #
3814 # You should have received a copy of the GNU General Public License version
3815 # 2 along with this work; if not, write to the Free Software Foundation,
3816 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3817 #
3818 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3819 # or visit www.oracle.com if you need additional information or have any
3820 # questions.
3821 #
3822 
3823 ########################################################################
3824 # This file handles detection of the Boot JDK. The Boot JDK detection
3825 # process has been developed as a response to solve a complex real-world
3826 # problem. Initially, it was simple, but it has grown as platform after
3827 # platform, idiosyncracy after idiosyncracy has been supported.
3828 #
3829 # The basic idea is this:
3830 # 1) You need an acceptable *) JDK to use as a Boot JDK
3831 # 2) There are several ways to locate a JDK, that are mostly platform
3832 #    dependent **)
3833 # 3) You can have multiple JDKs installed
3834 # 4) If possible, configure should try to dig out an acceptable JDK
3835 #    automatically, without having to resort to command-line options
3836 #
3837 # *)  acceptable means e.g. JDK7 for building JDK8, a complete JDK (with
3838 #     javac) and not a JRE, etc.
3839 #
3840 # **) On Windows we typically use a well-known path.
3841 #     On MacOSX we typically use the tool java_home.
3842 #     On Linux we typically find javac in the $PATH, and then follow a
3843 #     chain of symlinks that often ends up in a real JDK.
3844 #
3845 # This leads to the code where we check in different ways to locate a
3846 # JDK, and if one is found, check if it is acceptable. If not, we print
3847 # our reasons for rejecting it (useful when debugging non-working
3848 # configure situations) and continue checking the next one.
3849 ########################################################################
3850 
3851 # Execute the check given as argument, and verify the result
3852 # If the Boot JDK was previously found, do nothing
3853 # $1 A command line (typically autoconf macro) to execute
3854 
3855 
3856 # Test: Is bootjdk explicitely set by command line arguments?
3857 
3858 
3859 # Test: Is $JAVA_HOME set?
3860 
3861 
3862 # Test: Is there a java or javac in the PATH, which is a symlink to the JDK?
3863 
3864 
3865 # Test: Is there a /usr/libexec/java_home? (Typically on MacOSX)
3866 # $1: Argument to the java_home binary (optional)
3867 
3868 
3869 # Test: On MacOS X, can we find a boot jdk using /usr/libexec/java_home?
3870 
3871 
3872 # Look for a jdk in the given path. If there are multiple, try to select the newest.
3873 # If found, set BOOT_JDK and BOOT_JDK_FOUND.
3874 # $1 = Path to directory containing jdk installations.
3875 # $2 = String to append to the found JDK directory to get the proper JDK home
3876 
3877 
3878 # Call BOOTJDK_FIND_BEST_JDK_IN_DIRECTORY, but use the given
3879 # environmental variable as base for where to look.
3880 # $1 Name of an environmal variable, assumed to point to the Program Files directory.
3881 
3882 
3883 # Test: Is there a JDK installed in default, well-known locations?
3884 
3885 
3886 # Check that a command-line tool in the Boot JDK is correct
3887 # $1 = name of variable to assign
3888 # $2 = name of binary
3889 
3890 
3891 ###############################################################################
3892 #
3893 # We need a Boot JDK to bootstrap the build.
3894 #
3895 
3896 
3897 
3898 
3899 
3900 # BUILD_JDK: the location of the latest JDK that can run
3901 #   on the host system and supports the target class file version
3902 #   generated in this JDK build.  This variable should only be
3903 #   used after the launchers are built.
3904 #
3905 
3906 # Execute the check given as argument, and verify the result.
3907 # If the JDK was previously found, do nothing.
3908 # $1 A command line (typically autoconf macro) to execute
3909 
3910 
3911 # By default the BUILD_JDK is the JDK_OUTPUTDIR.  If the target architecture
3912 # is different than the host system doing the build (e.g. cross-compilation),
3913 # a special BUILD_JDK is built as part of the build process.  An external
3914 # prebuilt BUILD_JDK can also be supplied.
3915 
3916 
3917 #
3918 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
3919 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3920 #
3921 # This code is free software; you can redistribute it and/or modify it
3922 # under the terms of the GNU General Public License version 2 only, as
3923 # published by the Free Software Foundation.  Oracle designates this
3924 # particular file as subject to the "Classpath" exception as provided
3925 # by Oracle in the LICENSE file that accompanied this code.
3926 #
3927 # This code is distributed in the hope that it will be useful, but WITHOUT
3928 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3929 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3930 # version 2 for more details (a copy is included in the LICENSE file that
3931 # accompanied this code).
3932 #
3933 # You should have received a copy of the GNU General Public License version
3934 # 2 along with this work; if not, write to the Free Software Foundation,
3935 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3936 #
3937 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3938 # or visit www.oracle.com if you need additional information or have any
3939 # questions.
3940 #
3941 
3942 
3943 
3944 
3945 
3946 
3947 
3948 
3949 
3950 
3951 
3952 
3953 
3954 
3955 
3956 
3957 
3958 ################################################################################
3959 #
3960 # Runs icecc-create-env once and prints the error if it fails
3961 #
3962 # $1: arguments to icecc-create-env
3963 # $2: log file
3964 #
3965 
3966 
3967 ################################################################################
3968 #
3969 # Optionally enable distributed compilation of native code using icecc/icecream
3970 #
3971 
3972 
3973 
3974 
3975 
3976 
3977 
3978 #
3979 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
3980 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3981 #
3982 # This code is free software; you can redistribute it and/or modify it
3983 # under the terms of the GNU General Public License version 2 only, as
3984 # published by the Free Software Foundation.  Oracle designates this
3985 # particular file as subject to the "Classpath" exception as provided
3986 # by Oracle in the LICENSE file that accompanied this code.
3987 #
3988 # This code is distributed in the hope that it will be useful, but WITHOUT
3989 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3990 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3991 # version 2 for more details (a copy is included in the LICENSE file that
3992 # accompanied this code).
3993 #
3994 # You should have received a copy of the GNU General Public License version
3995 # 2 along with this work; if not, write to the Free Software Foundation,
3996 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3997 #
3998 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3999 # or visit www.oracle.com if you need additional information or have any
4000 # questions.
4001 #
4002 
4003 # Reset the global CFLAGS/LDFLAGS variables and initialize them with the
4004 # corresponding configure arguments instead
4005 
4006 
4007 # Setup the sysroot flags and add them to global CFLAGS and LDFLAGS so
4008 # that configure can use them while detecting compilers.
4009 # TOOLCHAIN_TYPE is available here.
4010 # Param 1 - Optional prefix to all variables. (e.g BUILD_)
4011 
4012 
4013 
4014 
4015 
4016 
4017 # Documentation on common flags used for solstudio in HIGHEST.
4018 #
4019 # WARNING: Use of OPTIMIZATION_LEVEL=HIGHEST in your Makefile needs to be
4020 #          done with care, there are some assumptions below that need to
4021 #          be understood about the use of pointers, and IEEE behavior.
4022 #
4023 # -fns: Use non-standard floating point mode (not IEEE 754)
4024 # -fsimple: Do some simplification of floating point arithmetic (not IEEE 754)
4025 # -fsingle: Use single precision floating point with 'float'
4026 # -xalias_level=basic: Assume memory references via basic pointer types do not alias
4027 #   (Source with excessing pointer casting and data access with mixed
4028 #    pointer types are not recommended)
4029 # -xbuiltin=%all: Use intrinsic or inline versions for math/std functions
4030 #   (If you expect perfect errno behavior, do not use this)
4031 # -xdepend: Loop data dependency optimizations (need -xO3 or higher)
4032 # -xrestrict: Pointer parameters to functions do not overlap
4033 #   (Similar to -xalias_level=basic usage, but less obvious sometimes.
4034 #    If you pass in multiple pointers to the same data, do not use this)
4035 # -xlibmil: Inline some library routines
4036 #   (If you expect perfect errno behavior, do not use this)
4037 # -xlibmopt: Use optimized math routines (CURRENTLY DISABLED)
4038 #   (If you expect perfect errno behavior, do not use this)
4039 #  Can cause undefined external on Solaris 8 X86 on __sincos, removing for now
4040 
4041     # FIXME: this will never happen since sparc != sparcv9, ie 32 bit, which we don't build anymore.
4042     # Bug?
4043     #if test "x$OPENJDK_TARGET_CPU" = xsparc; then
4044     #  CFLAGS_JDK="${CFLAGS_JDK} -xmemalign=4s"
4045     #  CXXFLAGS_JDK="${CXXFLAGS_JDK} -xmemalign=4s"
4046     #fi
4047 
4048 
4049 
4050 
4051 
4052 
4053 ################################################################################
4054 # $1 - Either BUILD or TARGET to pick the correct OS/CPU variables to check
4055 #      conditionals against.
4056 # $2 - Optional prefix for each variable defined.
4057 
4058 
4059 # FLAGS_C_COMPILER_CHECK_ARGUMENTS(ARGUMENT: [ARGUMENT], IF_TRUE: [RUN-IF-TRUE],
4060 #                                  IF_FALSE: [RUN-IF-FALSE])
4061 # ------------------------------------------------------------
4062 # Check that the C compiler supports an argument
4063 
4064 
4065 
4066 
4067 # FLAGS_CXX_COMPILER_CHECK_ARGUMENTS(ARGUMENT: [ARGUMENT], IF_TRUE: [RUN-IF-TRUE],
4068 #                                    IF_FALSE: [RUN-IF-FALSE])
4069 # ------------------------------------------------------------
4070 # Check that the C++ compiler supports an argument
4071 
4072 
4073 
4074 
4075 # FLAGS_COMPILER_CHECK_ARGUMENTS(ARGUMENT: [ARGUMENT], IF_TRUE: [RUN-IF-TRUE],
4076 #                                IF_FALSE: [RUN-IF-FALSE])
4077 # ------------------------------------------------------------
4078 # Check that the C and C++ compilers support an argument
4079 
4080 
4081 
4082 
4083 # FLAGS_LINKER_CHECK_ARGUMENTS(ARGUMENT: [ARGUMENT], IF_TRUE: [RUN-IF-TRUE],
4084 #                                   IF_FALSE: [RUN-IF-FALSE])
4085 # ------------------------------------------------------------
4086 # Check that the linker support an argument
4087 
4088 
4089 
4090 
4091 
4092 
4093 # FLAGS_SETUP_GCC6_COMPILER_FLAGS([PREFIX])
4094 # Arguments:
4095 # $1 - Optional prefix for each variable defined.
4096 
4097 
4098 #
4099 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
4100 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4101 #
4102 # This code is free software; you can redistribute it and/or modify it
4103 # under the terms of the GNU General Public License version 2 only, as
4104 # published by the Free Software Foundation.  Oracle designates this
4105 # particular file as subject to the "Classpath" exception as provided
4106 # by Oracle in the LICENSE file that accompanied this code.
4107 #
4108 # This code is distributed in the hope that it will be useful, but WITHOUT
4109 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4110 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4111 # version 2 for more details (a copy is included in the LICENSE file that
4112 # accompanied this code).
4113 #
4114 # You should have received a copy of the GNU General Public License version
4115 # 2 along with this work; if not, write to the Free Software Foundation,
4116 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4117 #
4118 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4119 # or visit www.oracle.com if you need additional information or have any
4120 # questions.
4121 #
4122 
4123 
4124 
4125 
4126 
4127 cygwin_help() {
4128   case $1 in
4129     unzip)
4130       PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P unzip )"
4131       HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
4132       ;;
4133     zip)
4134       PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P zip )"
4135       HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
4136       ;;
4137     make)
4138       PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P make )"
4139       HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
4140       ;;
4141     freetype)
4142       HELP_MSG="
4143 The freetype library can now be build during the configure process.
4144 Download the freetype sources and unpack them into an arbitrary directory:
4145 
4146 wget http://download.savannah.gnu.org/releases/freetype/freetype-2.5.3.tar.gz
4147 tar -xzf freetype-2.5.3.tar.gz
4148 
4149 Then run configure with '--with-freetype-src=<freetype_src>'. This will
4150 automatically build the freetype library into '<freetype_src>/lib64' for 64-bit
4151 builds or into '<freetype_src>/lib32' for 32-bit builds.
4152 Afterwards you can always use '--with-freetype-include=<freetype_src>/include'
4153 and '--with-freetype-lib=<freetype_src>/lib32|64' for other builds.
4154 
4155 Alternatively you can unpack the sources like this to use the default directory:
4156 
4157 tar --one-top-level=$HOME/freetype --strip-components=1 -xzf freetype-2.5.3.tar.gz"
4158       ;;
4159   esac
4160 }
4161 
4162 msys_help() {
4163   PKGHANDLER_COMMAND=""
4164 }
4165 
4166 apt_help() {
4167   case $1 in
4168     reduced)
4169       PKGHANDLER_COMMAND="sudo apt-get install gcc-multilib g++-multilib" ;;
4170     devkit)
4171       PKGHANDLER_COMMAND="sudo apt-get install build-essential" ;;
4172     openjdk)
4173       PKGHANDLER_COMMAND="sudo apt-get install openjdk-8-jdk" ;;
4174     alsa)
4175       PKGHANDLER_COMMAND="sudo apt-get install libasound2-dev" ;;
4176     cups)
4177       PKGHANDLER_COMMAND="sudo apt-get install libcups2-dev" ;;
4178     freetype)
4179       PKGHANDLER_COMMAND="sudo apt-get install libfreetype6-dev" ;;
4180     ffi)
4181       PKGHANDLER_COMMAND="sudo apt-get install libffi-dev" ;;
4182     x11)
4183       PKGHANDLER_COMMAND="sudo apt-get install libX11-dev libxext-dev libxrender-dev libxtst-dev libxt-dev" ;;
4184     ccache)
4185       PKGHANDLER_COMMAND="sudo apt-get install ccache" ;;
4186     dtrace)
4187       PKGHANDLER_COMMAND="sudo apt-get install systemtap-sdt-dev" ;;
4188   esac
4189 }
4190 
4191 yum_help() {
4192   case $1 in
4193     devkit)
4194       PKGHANDLER_COMMAND="sudo yum groupinstall \"Development Tools\"" ;;
4195     openjdk)
4196       PKGHANDLER_COMMAND="sudo yum install java-1.8.0-openjdk-devel" ;;
4197     alsa)
4198       PKGHANDLER_COMMAND="sudo yum install alsa-lib-devel" ;;
4199     cups)
4200       PKGHANDLER_COMMAND="sudo yum install cups-devel" ;;
4201     freetype)
4202       PKGHANDLER_COMMAND="sudo yum install freetype-devel" ;;
4203     x11)
4204       PKGHANDLER_COMMAND="sudo yum install libXtst-devel libXt-devel libXrender-devel libXi-devel" ;;
4205     ccache)
4206       PKGHANDLER_COMMAND="sudo yum install ccache" ;;
4207   esac
4208 }
4209 
4210 port_help() {
4211   PKGHANDLER_COMMAND=""
4212 }
4213 
4214 pkgutil_help() {
4215   PKGHANDLER_COMMAND=""
4216 }
4217 
4218 pkgadd_help() {
4219   PKGHANDLER_COMMAND=""
4220 }
4221 
4222 # This function will check if we're called from the "configure" wrapper while
4223 # printing --help. If so, we will print out additional information that can
4224 # only be extracted within the autoconf script, and then exit. This must be
4225 # called at the very beginning in configure.ac.
4226 
4227 
4228 
4229 
4230 
4231 
4232 #
4233 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
4234 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4235 #
4236 # This code is free software; you can redistribute it and/or modify it
4237 # under the terms of the GNU General Public License version 2 only, as
4238 # published by the Free Software Foundation.  Oracle designates this
4239 # particular file as subject to the "Classpath" exception as provided
4240 # by Oracle in the LICENSE file that accompanied this code.
4241 #
4242 # This code is distributed in the hope that it will be useful, but WITHOUT
4243 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4244 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4245 # version 2 for more details (a copy is included in the LICENSE file that
4246 # accompanied this code).
4247 #
4248 # You should have received a copy of the GNU General Public License version
4249 # 2 along with this work; if not, write to the Free Software Foundation,
4250 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4251 #
4252 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4253 # or visit www.oracle.com if you need additional information or have any
4254 # questions.
4255 #
4256 
4257 # All valid JVM features, regardless of platform
4258 VALID_JVM_FEATURES="compiler1 compiler2 zero shark minimal dtrace jvmti jvmci \
4259     fprof vm-structs jni-check services management all-gcs nmt cds static-build"
4260 
4261 # All valid JVM variants
4262 VALID_JVM_VARIANTS="server client minimal core zero zeroshark custom"
4263 
4264 ###############################################################################
4265 # Check if the specified JVM variant should be built. To be used in shell if
4266 # constructs, like this:
4267 # if HOTSPOT_CHECK_JVM_VARIANT(server); then
4268 #
4269 # Only valid to use after HOTSPOT_SETUP_JVM_VARIANTS has setup variants.
4270 
4271 # Definition kept in one line to allow inlining in if statements.
4272 # Additional [] needed to keep m4 from mangling shell constructs.
4273 
4274 
4275 ###############################################################################
4276 # Check if the specified JVM features are explicitly enabled. To be used in
4277 # shell if constructs, like this:
4278 # if HOTSPOT_CHECK_JVM_FEATURE(jvmti); then
4279 #
4280 # Only valid to use after HOTSPOT_SETUP_JVM_FEATURES has setup features.
4281 
4282 # Definition kept in one line to allow inlining in if statements.
4283 # Additional [] needed to keep m4 from mangling shell constructs.
4284 
4285 
4286 ###############################################################################
4287 # Check which variants of the JVM that we want to build. Available variants are:
4288 #   server: normal interpreter, and a tiered C1/C2 compiler
4289 #   client: normal interpreter, and C1 (no C2 compiler)
4290 #   minimal: reduced form of client with optional features stripped out
4291 #   core: normal interpreter only, no compiler
4292 #   zero: C++ based interpreter only, no compiler
4293 #   zeroshark: C++ based interpreter, and a llvm-based compiler
4294 #   custom: baseline JVM with no default features
4295 #
4296 
4297 
4298 ###############################################################################
4299 # Check if dtrace should be enabled and has all prerequisites present.
4300 #
4301 
4302 
4303 ###############################################################################
4304 # Set up all JVM features for each JVM variant.
4305 #
4306 
4307 
4308 ###############################################################################
4309 # Validate JVM features once all setup is complete, including custom setup.
4310 #
4311 
4312 
4313 ################################################################################
4314 # Check if gtest should be built
4315 #
4316 
4317 
4318 #
4319 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
4320 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4321 #
4322 # This code is free software; you can redistribute it and/or modify it
4323 # under the terms of the GNU General Public License version 2 only, as
4324 # published by the Free Software Foundation.  Oracle designates this
4325 # particular file as subject to the "Classpath" exception as provided
4326 # by Oracle in the LICENSE file that accompanied this code.
4327 #
4328 # This code is distributed in the hope that it will be useful, but WITHOUT
4329 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4330 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4331 # version 2 for more details (a copy is included in the LICENSE file that
4332 # accompanied this code).
4333 #
4334 # You should have received a copy of the GNU General Public License version
4335 # 2 along with this work; if not, write to the Free Software Foundation,
4336 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4337 #
4338 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4339 # or visit www.oracle.com if you need additional information or have any
4340 # questions.
4341 #
4342 
4343 ###############################################################################
4344 # Check which variant of the JDK that we want to build.
4345 # Currently we have:
4346 #    normal:   standard edition
4347 # but the custom make system may add other variants
4348 #
4349 # Effectively the JDK variant gives a name to a specific set of
4350 # modules to compile into the JDK.
4351 
4352 
4353 ###############################################################################
4354 # Set the debug level
4355 #    release: no debug information, all optimizations, no asserts.
4356 #    optimized: no debug information, all optimizations, no asserts, HotSpot target is 'optimized'.
4357 #    fastdebug: debug information (-g), all optimizations, all asserts
4358 #    slowdebug: debug information (-g), no optimizations, all asserts
4359 
4360 
4361 ###############################################################################
4362 #
4363 # Should we build only OpenJDK even if closed sources are present?
4364 #
4365 
4366 
4367 
4368 
4369 ###############################################################################
4370 #
4371 # Enable or disable the elliptic curve crypto implementation
4372 #
4373 
4374 
4375 
4376 
4377 ################################################################################
4378 #
4379 # Gcov coverage data for hotspot
4380 #
4381 
4382 
4383 ################################################################################
4384 #
4385 # Static build support.  When enabled will generate static
4386 # libraries instead of shared libraries for all JDK libs.
4387 #
4388 
4389 
4390 ################################################################################
4391 #
4392 # jlink options.
4393 # We always keep packaged modules in JDK image.
4394 #
4395 
4396 
4397 ################################################################################
4398 #
4399 # Check if building of the jtreg failure handler should be enabled.
4400 #
4401 
4402 
4403 ################################################################################
4404 #
4405 # Enable or disable generation of the classlist at build time
4406 #
4407 
4408 
4409 #
4410 # Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
4411 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4412 #
4413 # This code is free software; you can redistribute it and/or modify it
4414 # under the terms of the GNU General Public License version 2 only, as
4415 # published by the Free Software Foundation.  Oracle designates this
4416 # particular file as subject to the "Classpath" exception as provided
4417 # by Oracle in the LICENSE file that accompanied this code.
4418 #
4419 # This code is distributed in the hope that it will be useful, but WITHOUT
4420 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4421 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4422 # version 2 for more details (a copy is included in the LICENSE file that
4423 # accompanied this code).
4424 #
4425 # You should have received a copy of the GNU General Public License version
4426 # 2 along with this work; if not, write to the Free Software Foundation,
4427 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4428 #
4429 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4430 # or visit www.oracle.com if you need additional information or have any
4431 # questions.
4432 #
4433 
4434 ###############################################################################
4435 #
4436 # Setup version numbers
4437 #
4438 
4439 # Verify that a given string represents a valid version number, and assign it
4440 # to a variable.
4441 
4442 # Argument 1: the variable to assign to
4443 # Argument 2: the value given by the user
4444 
4445 
4446 
4447 
4448 #
4449 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
4450 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4451 #
4452 # This code is free software; you can redistribute it and/or modify it
4453 # under the terms of the GNU General Public License version 2 only, as
4454 # published by the Free Software Foundation.  Oracle designates this
4455 # particular file as subject to the "Classpath" exception as provided
4456 # by Oracle in the LICENSE file that accompanied this code.
4457 #
4458 # This code is distributed in the hope that it will be useful, but WITHOUT
4459 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4460 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4461 # version 2 for more details (a copy is included in the LICENSE file that
4462 # accompanied this code).
4463 #
4464 # You should have received a copy of the GNU General Public License version
4465 # 2 along with this work; if not, write to the Free Software Foundation,
4466 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4467 #
4468 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4469 # or visit www.oracle.com if you need additional information or have any
4470 # questions.
4471 #
4472 
4473 # Major library component reside in separate files.
4474 #
4475 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
4476 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4477 #
4478 # This code is free software; you can redistribute it and/or modify it
4479 # under the terms of the GNU General Public License version 2 only, as
4480 # published by the Free Software Foundation.  Oracle designates this
4481 # particular file as subject to the "Classpath" exception as provided
4482 # by Oracle in the LICENSE file that accompanied this code.
4483 #
4484 # This code is distributed in the hope that it will be useful, but WITHOUT
4485 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4486 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4487 # version 2 for more details (a copy is included in the LICENSE file that
4488 # accompanied this code).
4489 #
4490 # You should have received a copy of the GNU General Public License version
4491 # 2 along with this work; if not, write to the Free Software Foundation,
4492 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4493 #
4494 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4495 # or visit www.oracle.com if you need additional information or have any
4496 # questions.
4497 #
4498 
4499 ################################################################################
4500 # Setup alsa (Advanced Linux Sound Architecture)
4501 ################################################################################
4502 
4503 
4504 #
4505 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
4506 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4507 #
4508 # This code is free software; you can redistribute it and/or modify it
4509 # under the terms of the GNU General Public License version 2 only, as
4510 # published by the Free Software Foundation.  Oracle designates this
4511 # particular file as subject to the "Classpath" exception as provided
4512 # by Oracle in the LICENSE file that accompanied this code.
4513 #
4514 # This code is distributed in the hope that it will be useful, but WITHOUT
4515 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4516 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4517 # version 2 for more details (a copy is included in the LICENSE file that
4518 # accompanied this code).
4519 #
4520 # You should have received a copy of the GNU General Public License version
4521 # 2 along with this work; if not, write to the Free Software Foundation,
4522 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4523 #
4524 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4525 # or visit www.oracle.com if you need additional information or have any
4526 # questions.
4527 #
4528 
4529 ################################################################################
4530 # Setup bundled libraries.
4531 #
4532 # For libjpeg, giflib, libpng, lcms2 and zlib, the source is present in the
4533 # OpenJDK repository. Default is to use these libraries as bundled, but they
4534 # might be replaced by en external version by the user.
4535 ################################################################################
4536 
4537 
4538 ################################################################################
4539 # Setup libjpeg
4540 ################################################################################
4541 
4542 
4543 ################################################################################
4544 # Setup giflib
4545 ################################################################################
4546 
4547 
4548 ################################################################################
4549 # Setup libpng
4550 ################################################################################
4551 
4552 
4553 ################################################################################
4554 # Setup zlib
4555 ################################################################################
4556 
4557 
4558 ################################################################################
4559 # Setup lcms (Little CMS)
4560 ################################################################################
4561 
4562 
4563 #
4564 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
4565 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4566 #
4567 # This code is free software; you can redistribute it and/or modify it
4568 # under the terms of the GNU General Public License version 2 only, as
4569 # published by the Free Software Foundation.  Oracle designates this
4570 # particular file as subject to the "Classpath" exception as provided
4571 # by Oracle in the LICENSE file that accompanied this code.
4572 #
4573 # This code is distributed in the hope that it will be useful, but WITHOUT
4574 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4575 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4576 # version 2 for more details (a copy is included in the LICENSE file that
4577 # accompanied this code).
4578 #
4579 # You should have received a copy of the GNU General Public License version
4580 # 2 along with this work; if not, write to the Free Software Foundation,
4581 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4582 #
4583 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4584 # or visit www.oracle.com if you need additional information or have any
4585 # questions.
4586 #
4587 
4588 ################################################################################
4589 # Setup cups (Common Unix Printing System)
4590 ################################################################################
4591 
4592 
4593 #
4594 # Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
4595 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4596 #
4597 # This code is free software; you can redistribute it and/or modify it
4598 # under the terms of the GNU General Public License version 2 only, as
4599 # published by the Free Software Foundation.  Oracle designates this
4600 # particular file as subject to the "Classpath" exception as provided
4601 # by Oracle in the LICENSE file that accompanied this code.
4602 #
4603 # This code is distributed in the hope that it will be useful, but WITHOUT
4604 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4605 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4606 # version 2 for more details (a copy is included in the LICENSE file that
4607 # accompanied this code).
4608 #
4609 # You should have received a copy of the GNU General Public License version
4610 # 2 along with this work; if not, write to the Free Software Foundation,
4611 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4612 #
4613 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4614 # or visit www.oracle.com if you need additional information or have any
4615 # questions.
4616 #
4617 
4618 ################################################################################
4619 # Setup libffi (Foreign Function Interface)
4620 ################################################################################
4621 
4622 
4623 #
4624 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
4625 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4626 #
4627 # This code is free software; you can redistribute it and/or modify it
4628 # under the terms of the GNU General Public License version 2 only, as
4629 # published by the Free Software Foundation.  Oracle designates this
4630 # particular file as subject to the "Classpath" exception as provided
4631 # by Oracle in the LICENSE file that accompanied this code.
4632 #
4633 # This code is distributed in the hope that it will be useful, but WITHOUT
4634 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4635 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4636 # version 2 for more details (a copy is included in the LICENSE file that
4637 # accompanied this code).
4638 #
4639 # You should have received a copy of the GNU General Public License version
4640 # 2 along with this work; if not, write to the Free Software Foundation,
4641 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4642 #
4643 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4644 # or visit www.oracle.com if you need additional information or have any
4645 # questions.
4646 #
4647 
4648 ################################################################################
4649 # Build the freetype lib from source
4650 ################################################################################
4651 
4652 
4653 ################################################################################
4654 # Check if a potential freeype library match is correct and usable
4655 ################################################################################
4656 
4657 
4658 ################################################################################
4659 # Setup freetype (The FreeType2 font rendering library)
4660 ################################################################################
4661 
4662 
4663 #
4664 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
4665 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4666 #
4667 # This code is free software; you can redistribute it and/or modify it
4668 # under the terms of the GNU General Public License version 2 only, as
4669 # published by the Free Software Foundation.  Oracle designates this
4670 # particular file as subject to the "Classpath" exception as provided
4671 # by Oracle in the LICENSE file that accompanied this code.
4672 #
4673 # This code is distributed in the hope that it will be useful, but WITHOUT
4674 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4675 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4676 # version 2 for more details (a copy is included in the LICENSE file that
4677 # accompanied this code).
4678 #
4679 # You should have received a copy of the GNU General Public License version
4680 # 2 along with this work; if not, write to the Free Software Foundation,
4681 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4682 #
4683 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4684 # or visit www.oracle.com if you need additional information or have any
4685 # questions.
4686 #
4687 
4688 ################################################################################
4689 # Setup the standard C/C++ runtime libraries.
4690 #
4691 # Most importantly, determine if stdc++ should be linked statically or
4692 # dynamically.
4693 ################################################################################
4694 
4695 
4696 #
4697 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
4698 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4699 #
4700 # This code is free software; you can redistribute it and/or modify it
4701 # under the terms of the GNU General Public License version 2 only, as
4702 # published by the Free Software Foundation.  Oracle designates this
4703 # particular file as subject to the "Classpath" exception as provided
4704 # by Oracle in the LICENSE file that accompanied this code.
4705 #
4706 # This code is distributed in the hope that it will be useful, but WITHOUT
4707 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4708 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4709 # version 2 for more details (a copy is included in the LICENSE file that
4710 # accompanied this code).
4711 #
4712 # You should have received a copy of the GNU General Public License version
4713 # 2 along with this work; if not, write to the Free Software Foundation,
4714 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4715 #
4716 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4717 # or visit www.oracle.com if you need additional information or have any
4718 # questions.
4719 #
4720 
4721 ################################################################################
4722 # Setup X11 Windows system
4723 ################################################################################
4724 
4725 
4726 
4727 ################################################################################
4728 # Determine which libraries are needed for this configuration
4729 ################################################################################
4730 
4731 
4732 ################################################################################
4733 # Parse library options, and setup needed libraries
4734 ################################################################################
4735 
4736 
4737 ################################################################################
4738 # Setup llvm (Low-Level VM)
4739 ################################################################################
4740 
4741 
4742 ################################################################################
4743 # Setup various libraries, typically small system libraries
4744 ################################################################################
4745 
4746 
4747 ################################################################################
4748 # libstlport.so.1 is needed for running gtest on Solaris. Find it to
4749 # redistribute it in the test image.
4750 ################################################################################
4751 
4752 
4753 
4754 #
4755 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
4756 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4757 #
4758 # This code is free software; you can redistribute it and/or modify it
4759 # under the terms of the GNU General Public License version 2 only, as
4760 # published by the Free Software Foundation.  Oracle designates this
4761 # particular file as subject to the "Classpath" exception as provided
4762 # by Oracle in the LICENSE file that accompanied this code.
4763 #
4764 # This code is distributed in the hope that it will be useful, but WITHOUT
4765 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4766 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4767 # version 2 for more details (a copy is included in the LICENSE file that
4768 # accompanied this code).
4769 #
4770 # You should have received a copy of the GNU General Public License version
4771 # 2 along with this work; if not, write to the Free Software Foundation,
4772 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4773 #
4774 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4775 # or visit www.oracle.com if you need additional information or have any
4776 # questions.
4777 #
4778 
4779 # Support macro for PLATFORM_EXTRACT_TARGET_AND_BUILD.
4780 # Converts autoconf style CPU name to OpenJDK style, into
4781 # VAR_CPU, VAR_CPU_ARCH, VAR_CPU_BITS and VAR_CPU_ENDIAN.
4782 
4783 
4784 # Support macro for PLATFORM_EXTRACT_TARGET_AND_BUILD.
4785 # Converts autoconf style OS name to OpenJDK style, into
4786 # VAR_OS, VAR_OS_TYPE and VAR_OS_ENV.
4787 
4788 
4789 # Expects $host_os $host_cpu $build_os and $build_cpu
4790 # and $with_target_bits to have been setup!
4791 #
4792 # Translate the standard triplet(quadruplet) definition
4793 # of the target/build system into OPENJDK_TARGET_OS, OPENJDK_TARGET_CPU,
4794 # OPENJDK_BUILD_OS, etc.
4795 
4796 
4797 # Check if a reduced build (32-bit on 64-bit platforms) is requested, and modify behaviour
4798 # accordingly. Must be done after setting up build and target system, but before
4799 # doing anything else with these values.
4800 
4801 
4802 # Setup the legacy variables, for controlling the old makefiles.
4803 #
4804 
4805 
4806 # $1 - Either TARGET or BUILD to setup the variables for.
4807 
4808 
4809 
4810 
4811 #%%% Build and target systems %%%
4812 
4813 
4814 
4815 
4816 # Support macro for PLATFORM_SETUP_OPENJDK_TARGET_BITS.
4817 # Add -mX to various FLAGS variables.
4818 
4819 
4820 
4821 
4822 
4823 
4824 #
4825 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
4826 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4827 #
4828 # This code is free software; you can redistribute it and/or modify it
4829 # under the terms of the GNU General Public License version 2 only, as
4830 # published by the Free Software Foundation.  Oracle designates this
4831 # particular file as subject to the "Classpath" exception as provided
4832 # by Oracle in the LICENSE file that accompanied this code.
4833 #
4834 # This code is distributed in the hope that it will be useful, but WITHOUT
4835 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4836 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4837 # version 2 for more details (a copy is included in the LICENSE file that
4838 # accompanied this code).
4839 #
4840 # You should have received a copy of the GNU General Public License version
4841 # 2 along with this work; if not, write to the Free Software Foundation,
4842 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4843 #
4844 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4845 # or visit www.oracle.com if you need additional information or have any
4846 # questions.
4847 #
4848 
4849 
4850 
4851 
4852 
4853 
4854 
4855 ################################################################################
4856 # Define a mechanism for importing extra prebuilt modules
4857 #
4858 
4859 
4860 
4861 #
4862 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
4863 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4864 #
4865 # This code is free software; you can redistribute it and/or modify it
4866 # under the terms of the GNU General Public License version 2 only, as
4867 # published by the Free Software Foundation.  Oracle designates this
4868 # particular file as subject to the "Classpath" exception as provided
4869 # by Oracle in the LICENSE file that accompanied this code.
4870 #
4871 # This code is distributed in the hope that it will be useful, but WITHOUT
4872 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4873 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4874 # version 2 for more details (a copy is included in the LICENSE file that
4875 # accompanied this code).
4876 #
4877 # You should have received a copy of the GNU General Public License version
4878 # 2 along with this work; if not, write to the Free Software Foundation,
4879 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4880 #
4881 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4882 # or visit www.oracle.com if you need additional information or have any
4883 # questions.
4884 #
4885 
4886 ########################################################################
4887 # This file is responsible for detecting, verifying and setting up the
4888 # toolchain, i.e. the compiler, linker and related utilities. It will setup
4889 # proper paths to the binaries, but it will not setup any flags.
4890 #
4891 # The binaries used is determined by the toolchain type, which is the family of
4892 # compilers and related tools that are used.
4893 ########################################################################
4894 
4895 
4896 # All valid toolchains, regardless of platform (used by help.m4)
4897 VALID_TOOLCHAINS_all="gcc clang solstudio xlc microsoft"
4898 
4899 # These toolchains are valid on different platforms
4900 VALID_TOOLCHAINS_linux="gcc clang"
4901 VALID_TOOLCHAINS_solaris="solstudio"
4902 VALID_TOOLCHAINS_macosx="gcc clang"
4903 VALID_TOOLCHAINS_aix="xlc"
4904 VALID_TOOLCHAINS_windows="microsoft"
4905 
4906 # Toolchain descriptions
4907 TOOLCHAIN_DESCRIPTION_clang="clang/LLVM"
4908 TOOLCHAIN_DESCRIPTION_gcc="GNU Compiler Collection"
4909 TOOLCHAIN_DESCRIPTION_microsoft="Microsoft Visual Studio"
4910 TOOLCHAIN_DESCRIPTION_solstudio="Oracle Solaris Studio"
4911 TOOLCHAIN_DESCRIPTION_xlc="IBM XL C/C++"
4912 
4913 # Minimum supported versions, empty means unspecified
4914 TOOLCHAIN_MINIMUM_VERSION_clang="3.2"
4915 TOOLCHAIN_MINIMUM_VERSION_gcc="4.3"
4916 TOOLCHAIN_MINIMUM_VERSION_microsoft=""
4917 TOOLCHAIN_MINIMUM_VERSION_solstudio="5.13"
4918 TOOLCHAIN_MINIMUM_VERSION_xlc=""
4919 
4920 # Prepare the system so that TOOLCHAIN_CHECK_COMPILER_VERSION can be called.
4921 # Must have CC_VERSION_NUMBER and CXX_VERSION_NUMBER.
4922 # $1 - optional variable prefix for compiler and version variables (BUILD_)
4923 # $2 - optional variable prefix for comparable variable (OPENJDK_BUILD_)
4924 
4925 
4926 # Check if the configured compiler (C and C++) is of a specific version or
4927 # newer. TOOLCHAIN_PREPARE_FOR_VERSION_COMPARISONS must have been called before.
4928 #
4929 # Arguments:
4930 #   VERSION:   The version string to check against the found version
4931 #   IF_AT_LEAST:   block to run if the compiler is at least this version (>=)
4932 #   IF_OLDER_THAN:   block to run if the compiler is older than this version (<)
4933 #   PREFIX:   Optional variable prefix for compiler to compare version for (OPENJDK_BUILD_)
4934 
4935 
4936 
4937 
4938 # Setup a number of variables describing how native output files are
4939 # named on this platform/toolchain.
4940 
4941 
4942 # Determine which toolchain type to use, and make sure it is valid for this
4943 # platform. Setup various information about the selected toolchain.
4944 
4945 
4946 # Before we start detecting the toolchain executables, we might need some
4947 # special setup, e.g. additional paths etc.
4948 
4949 
4950 # Restore path, etc
4951 
4952 
4953 # Check if a compiler is of the toolchain type we expect, and save the version
4954 # information from it. If the compiler does not match the expected type,
4955 # this function will abort using AC_MSG_ERROR. If it matches, the version will
4956 # be stored in CC_VERSION_NUMBER/CXX_VERSION_NUMBER (as a dotted number), and
4957 # the full version string in CC_VERSION_STRING/CXX_VERSION_STRING.
4958 #
4959 # $1 = compiler to test (CC or CXX)
4960 # $2 = human readable name of compiler (C or C++)
4961 
4962 
4963 # Try to locate the given C or C++ compiler in the path, or otherwise.
4964 #
4965 # $1 = compiler to test (CC or CXX)
4966 # $2 = human readable name of compiler (C or C++)
4967 # $3 = list of compiler names to search for
4968 
4969 
4970 # Detect the core components of the toolchain, i.e. the compilers (CC and CXX),
4971 # preprocessor (CPP and CXXCPP), the linker (LD), the assembler (AS) and the
4972 # archiver (AR). Verify that the compilers are correct according to the
4973 # toolchain type.
4974 
4975 
4976 # Setup additional tools that is considered a part of the toolchain, but not the
4977 # core part. Many of these are highly platform-specific and do not exist,
4978 # and/or are not needed on all platforms.
4979 
4980 
4981 # Setup the build tools (i.e, the compiler and linker used to build programs
4982 # that should be run on the build platform, not the target platform, as a build
4983 # helper). Since the non-cross-compile case uses the normal, target compilers
4984 # for this, we can only do this after these have been setup.
4985 
4986 
4987 # Setup legacy variables that are still needed as alternative ways to refer to
4988 # parts of the toolchain.
4989 
4990 
4991 # Do some additional checks on the detected tools.
4992 
4993 
4994 # Setup the JTReg Regression Test Harness.
4995 
4996 
4997 #
4998 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
4999 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5000 #
5001 # This code is free software; you can redistribute it and/or modify it
5002 # under the terms of the GNU General Public License version 2 only, as
5003 # published by the Free Software Foundation.  Oracle designates this
5004 # particular file as subject to the "Classpath" exception as provided
5005 # by Oracle in the LICENSE file that accompanied this code.
5006 #
5007 # This code is distributed in the hope that it will be useful, but WITHOUT
5008 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
5009 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
5010 # version 2 for more details (a copy is included in the LICENSE file that
5011 # accompanied this code).
5012 #
5013 # You should have received a copy of the GNU General Public License version
5014 # 2 along with this work; if not, write to the Free Software Foundation,
5015 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
5016 #
5017 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
5018 # or visit www.oracle.com if you need additional information or have any
5019 # questions.
5020 #
5021 
5022 ################################################################################
5023 # The order of these defines the priority by which we try to find them.
5024 VALID_VS_VERSIONS="2013 2012 2010"
5025 
5026 VS_DESCRIPTION_2010="Microsoft Visual Studio 2010"
5027 VS_VERSION_INTERNAL_2010=100
5028 VS_MSVCR_2010=msvcr100.dll
5029 # We don't use msvcp on Visual Studio 2010
5030 #VS_MSVCP_2010=msvcp100.dll
5031 VS_ENVVAR_2010="VS100COMNTOOLS"
5032 VS_VS_INSTALLDIR_2010="Microsoft Visual Studio 10.0"
5033 VS_SDK_INSTALLDIR_2010="Microsoft SDKs/Windows/v7.1"
5034 VS_VS_PLATFORM_NAME_2010="v100"
5035 VS_SDK_PLATFORM_NAME_2010="Windows7.1SDK"
5036 
5037 VS_DESCRIPTION_2012="Microsoft Visual Studio 2012"
5038 VS_VERSION_INTERNAL_2012=110
5039 VS_MSVCR_2012=msvcr110.dll
5040 VS_MSVCP_2012=msvcp110.dll
5041 VS_ENVVAR_2012="VS110COMNTOOLS"
5042 VS_VS_INSTALLDIR_2012="Microsoft Visual Studio 11.0"
5043 VS_SDK_INSTALLDIR_2012=
5044 VS_VS_PLATFORM_NAME_2012="v110"
5045 VS_SDK_PLATFORM_NAME_2012=
5046 
5047 VS_DESCRIPTION_2013="Microsoft Visual Studio 2013"
5048 VS_VERSION_INTERNAL_2013=120
5049 VS_MSVCR_2013=msvcr120.dll
5050 VS_MSVCP_2013=msvcp120.dll
5051 VS_ENVVAR_2013="VS120COMNTOOLS"
5052 VS_VS_INSTALLDIR_2013="Microsoft Visual Studio 12.0"
5053 VS_SDK_INSTALLDIR_2013=
5054 VS_VS_PLATFORM_NAME_2013="v120"
5055 VS_SDK_PLATFORM_NAME_2013=
5056 
5057 ################################################################################
5058 
5059 
5060 
5061 ################################################################################
5062 
5063 
5064 
5065 ################################################################################
5066 # Finds the bat or cmd file in Visual Studio or the SDK that sets up a proper
5067 # build environment and assigns it to VS_ENV_CMD
5068 
5069 
5070 ################################################################################
5071 
5072 
5073 
5074 ################################################################################
5075 # Check if the VS env variables were setup prior to running configure.
5076 # If not, then find vcvarsall.bat and run it automatically, and integrate
5077 # the set env variables into the spec file.
5078 
5079 
5080 
5081 
5082 
5083 
5084 
5085 
5086 
5087 
5088 
5089 
5090 
5091 
5092 # This line needs to be here, verbatim, after all includes and the dummy hook
5093 # definitions. It is replaced with custom functionality when building
5094 # custom sources.
5095 #CUSTOM_AUTOCONF_INCLUDE
5096 
5097 # Do not change or remove the following line, it is needed for consistency checks:
5098 DATE_WHEN_GENERATED=1470863189
5099 
5100 ###############################################################################
5101 #
5102 # Initialization / Boot-strapping
5103 #
5104 # The bootstrapping process needs to solve the "chicken or the egg" problem,
5105 # thus it jumps back and forth, each time gaining something needed later on.
5106 #
5107 ###############################################################################
5108 
5109 # If we are requested to print additional help, do that and then exit.
5110 # This must be the very first call.
5111 
5112   if test "x$CONFIGURE_PRINT_ADDITIONAL_HELP" != x; then
5113 
5114     # Print available toolchains
5115     $PRINTF "The following toolchains are available as arguments to --with-toolchain-type.\n"
5116     $PRINTF "Which are valid to use depends on the build platform.\n"
5117     for toolchain in $VALID_TOOLCHAINS_all; do
5118       # Use indirect variable referencing
5119       toolchain_var_name=TOOLCHAIN_DESCRIPTION_$toolchain
5120       TOOLCHAIN_DESCRIPTION=${!toolchain_var_name}
5121       $PRINTF "  %-10s  %s\n" $toolchain "$TOOLCHAIN_DESCRIPTION"
5122     done
5123     $PRINTF "\n"
5124 
5125     # Print available jvm features
5126     $PRINTF "The following JVM features are available as arguments to --with-jvm-features.\n"
5127     $PRINTF "Which are valid to use depends on the target platform.\n  "
5128     $PRINTF "%s " $VALID_JVM_FEATURES
5129     $PRINTF "\n"
5130 
5131     # And now exit directly
5132     exit 0
5133   fi
5134 
5135 
5136 # Basic initialization that must happen first of all in the normal process.
5137 
5138   # Save the original command line. This is passed to us by the wrapper configure script.
5139 
5140   # Save the path variable before it gets changed
5141   ORIGINAL_PATH="$PATH"
5142 
5143   DATE_WHEN_CONFIGURED=`LANG=C date`
5144 
5145   { $as_echo "$as_me:${as_lineno-$LINENO}: Configuration created at $DATE_WHEN_CONFIGURED." >&5
5146 $as_echo "$as_me: Configuration created at $DATE_WHEN_CONFIGURED." >&6;}
5147   { $as_echo "$as_me:${as_lineno-$LINENO}: configure script generated at timestamp $DATE_WHEN_GENERATED." >&5
5148 $as_echo "$as_me: configure script generated at timestamp $DATE_WHEN_GENERATED." >&6;}
5149 
5150 
5151   # Start with tools that do not need have cross compilation support
5152   # and can be expected to be found in the default PATH. These tools are
5153   # used by configure.
5154 
5155   # First are all the simple required tools.
5156 
5157 
5158 
5159   # Publish this variable in the help.
5160 
5161 
5162   if [ -z "${BASENAME+x}" ]; then
5163     # The variable is not set by user, try to locate tool using the code snippet
5164     for ac_prog in basename
5165 do
5166   # Extract the first word of "$ac_prog", so it can be a program name with args.
5167 set dummy $ac_prog; ac_word=$2
5168 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5169 $as_echo_n "checking for $ac_word... " >&6; }
5170 if ${ac_cv_path_BASENAME+:} false; then :
5171   $as_echo_n "(cached) " >&6
5172 else
5173   case $BASENAME in
5174   [\\/]* | ?:[\\/]*)
5175   ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
5176   ;;
5177   *)
5178   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5179 for as_dir in $PATH
5180 do
5181   IFS=$as_save_IFS
5182   test -z "$as_dir" && as_dir=.
5183     for ac_exec_ext in '' $ac_executable_extensions; do
5184   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5185     ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
5186     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5187     break 2
5188   fi
5189 done
5190   done
5191 IFS=$as_save_IFS
5192 
5193   ;;
5194 esac
5195 fi
5196 BASENAME=$ac_cv_path_BASENAME
5197 if test -n "$BASENAME"; then
5198   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
5199 $as_echo "$BASENAME" >&6; }
5200 else
5201   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5202 $as_echo "no" >&6; }
5203 fi
5204 
5205 
5206   test -n "$BASENAME" && break
5207 done
5208 
5209   else
5210     # The variable is set, but is it from the command line or the environment?
5211 
5212     # Try to remove the string !BASENAME! from our list.
5213     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BASENAME!/}
5214     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5215       # If it failed, the variable was not from the command line. Ignore it,
5216       # but warn the user (except for BASH, which is always set by the calling BASH).
5217       if test "xBASENAME" != xBASH; then
5218         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BASENAME from the environment. Use command line variables instead." >&5
5219 $as_echo "$as_me: WARNING: Ignoring value of BASENAME from the environment. Use command line variables instead." >&2;}
5220       fi
5221       # Try to locate tool using the code snippet
5222       for ac_prog in basename
5223 do
5224   # Extract the first word of "$ac_prog", so it can be a program name with args.
5225 set dummy $ac_prog; ac_word=$2
5226 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5227 $as_echo_n "checking for $ac_word... " >&6; }
5228 if ${ac_cv_path_BASENAME+:} false; then :
5229   $as_echo_n "(cached) " >&6
5230 else
5231   case $BASENAME in
5232   [\\/]* | ?:[\\/]*)
5233   ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
5234   ;;
5235   *)
5236   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5237 for as_dir in $PATH
5238 do
5239   IFS=$as_save_IFS
5240   test -z "$as_dir" && as_dir=.
5241     for ac_exec_ext in '' $ac_executable_extensions; do
5242   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5243     ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
5244     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5245     break 2
5246   fi
5247 done
5248   done
5249 IFS=$as_save_IFS
5250 
5251   ;;
5252 esac
5253 fi
5254 BASENAME=$ac_cv_path_BASENAME
5255 if test -n "$BASENAME"; then
5256   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
5257 $as_echo "$BASENAME" >&6; }
5258 else
5259   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5260 $as_echo "no" >&6; }
5261 fi
5262 
5263 
5264   test -n "$BASENAME" && break
5265 done
5266 
5267     else
5268       # If it succeeded, then it was overridden by the user. We will use it
5269       # for the tool.
5270 
5271       # First remove it from the list of overridden variables, so we can test
5272       # for unknown variables in the end.
5273       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5274 
5275       # Check if we try to supply an empty value
5276       if test "x$BASENAME" = x; then
5277         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool BASENAME= (no value)" >&5
5278 $as_echo "$as_me: Setting user supplied tool BASENAME= (no value)" >&6;}
5279         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASENAME" >&5
5280 $as_echo_n "checking for BASENAME... " >&6; }
5281         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
5282 $as_echo "disabled" >&6; }
5283       else
5284         # Check if the provided tool contains a complete path.
5285         tool_specified="$BASENAME"
5286         tool_basename="${tool_specified##*/}"
5287         if test "x$tool_basename" = "x$tool_specified"; then
5288           # A command without a complete path is provided, search $PATH.
5289           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BASENAME=$tool_basename" >&5
5290 $as_echo "$as_me: Will search for user supplied tool BASENAME=$tool_basename" >&6;}
5291           # Extract the first word of "$tool_basename", so it can be a program name with args.
5292 set dummy $tool_basename; ac_word=$2
5293 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5294 $as_echo_n "checking for $ac_word... " >&6; }
5295 if ${ac_cv_path_BASENAME+:} false; then :
5296   $as_echo_n "(cached) " >&6
5297 else
5298   case $BASENAME in
5299   [\\/]* | ?:[\\/]*)
5300   ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
5301   ;;
5302   *)
5303   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5304 for as_dir in $PATH
5305 do
5306   IFS=$as_save_IFS
5307   test -z "$as_dir" && as_dir=.
5308     for ac_exec_ext in '' $ac_executable_extensions; do
5309   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5310     ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
5311     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5312     break 2
5313   fi
5314 done
5315   done
5316 IFS=$as_save_IFS
5317 
5318   ;;
5319 esac
5320 fi
5321 BASENAME=$ac_cv_path_BASENAME
5322 if test -n "$BASENAME"; then
5323   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
5324 $as_echo "$BASENAME" >&6; }
5325 else
5326   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5327 $as_echo "no" >&6; }
5328 fi
5329 
5330 
5331           if test "x$BASENAME" = x; then
5332             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5333           fi
5334         else
5335           # Otherwise we believe it is a complete path. Use it as it is.
5336           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BASENAME=$tool_specified" >&5
5337 $as_echo "$as_me: Will use user supplied tool BASENAME=$tool_specified" >&6;}
5338           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASENAME" >&5
5339 $as_echo_n "checking for BASENAME... " >&6; }
5340           if test ! -x "$tool_specified"; then
5341             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5342 $as_echo "not found" >&6; }
5343             as_fn_error $? "User supplied tool BASENAME=$tool_specified does not exist or is not executable" "$LINENO" 5
5344           fi
5345           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5346 $as_echo "$tool_specified" >&6; }
5347         fi
5348       fi
5349     fi
5350 
5351   fi
5352 
5353 
5354 
5355   if test "x$BASENAME" = x; then
5356     as_fn_error $? "Could not find required tool for BASENAME" "$LINENO" 5
5357   fi
5358 
5359 
5360 
5361 
5362 
5363   # Publish this variable in the help.
5364 
5365 
5366   if [ -z "${BASH+x}" ]; then
5367     # The variable is not set by user, try to locate tool using the code snippet
5368     for ac_prog in bash
5369 do
5370   # Extract the first word of "$ac_prog", so it can be a program name with args.
5371 set dummy $ac_prog; ac_word=$2
5372 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5373 $as_echo_n "checking for $ac_word... " >&6; }
5374 if ${ac_cv_path_BASH+:} false; then :
5375   $as_echo_n "(cached) " >&6
5376 else
5377   case $BASH in
5378   [\\/]* | ?:[\\/]*)
5379   ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
5380   ;;
5381   *)
5382   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5383 for as_dir in $PATH
5384 do
5385   IFS=$as_save_IFS
5386   test -z "$as_dir" && as_dir=.
5387     for ac_exec_ext in '' $ac_executable_extensions; do
5388   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5389     ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
5390     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5391     break 2
5392   fi
5393 done
5394   done
5395 IFS=$as_save_IFS
5396 
5397   ;;
5398 esac
5399 fi
5400 BASH=$ac_cv_path_BASH
5401 if test -n "$BASH"; then
5402   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
5403 $as_echo "$BASH" >&6; }
5404 else
5405   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5406 $as_echo "no" >&6; }
5407 fi
5408 
5409 
5410   test -n "$BASH" && break
5411 done
5412 
5413   else
5414     # The variable is set, but is it from the command line or the environment?
5415 
5416     # Try to remove the string !BASH! from our list.
5417     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BASH!/}
5418     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5419       # If it failed, the variable was not from the command line. Ignore it,
5420       # but warn the user (except for BASH, which is always set by the calling BASH).
5421       if test "xBASH" != xBASH; then
5422         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BASH from the environment. Use command line variables instead." >&5
5423 $as_echo "$as_me: WARNING: Ignoring value of BASH from the environment. Use command line variables instead." >&2;}
5424       fi
5425       # Try to locate tool using the code snippet
5426       for ac_prog in bash
5427 do
5428   # Extract the first word of "$ac_prog", so it can be a program name with args.
5429 set dummy $ac_prog; ac_word=$2
5430 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5431 $as_echo_n "checking for $ac_word... " >&6; }
5432 if ${ac_cv_path_BASH+:} false; then :
5433   $as_echo_n "(cached) " >&6
5434 else
5435   case $BASH in
5436   [\\/]* | ?:[\\/]*)
5437   ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
5438   ;;
5439   *)
5440   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5441 for as_dir in $PATH
5442 do
5443   IFS=$as_save_IFS
5444   test -z "$as_dir" && as_dir=.
5445     for ac_exec_ext in '' $ac_executable_extensions; do
5446   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5447     ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
5448     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5449     break 2
5450   fi
5451 done
5452   done
5453 IFS=$as_save_IFS
5454 
5455   ;;
5456 esac
5457 fi
5458 BASH=$ac_cv_path_BASH
5459 if test -n "$BASH"; then
5460   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
5461 $as_echo "$BASH" >&6; }
5462 else
5463   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5464 $as_echo "no" >&6; }
5465 fi
5466 
5467 
5468   test -n "$BASH" && break
5469 done
5470 
5471     else
5472       # If it succeeded, then it was overridden by the user. We will use it
5473       # for the tool.
5474 
5475       # First remove it from the list of overridden variables, so we can test
5476       # for unknown variables in the end.
5477       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5478 
5479       # Check if we try to supply an empty value
5480       if test "x$BASH" = x; then
5481         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool BASH= (no value)" >&5
5482 $as_echo "$as_me: Setting user supplied tool BASH= (no value)" >&6;}
5483         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASH" >&5
5484 $as_echo_n "checking for BASH... " >&6; }
5485         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
5486 $as_echo "disabled" >&6; }
5487       else
5488         # Check if the provided tool contains a complete path.
5489         tool_specified="$BASH"
5490         tool_basename="${tool_specified##*/}"
5491         if test "x$tool_basename" = "x$tool_specified"; then
5492           # A command without a complete path is provided, search $PATH.
5493           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BASH=$tool_basename" >&5
5494 $as_echo "$as_me: Will search for user supplied tool BASH=$tool_basename" >&6;}
5495           # Extract the first word of "$tool_basename", so it can be a program name with args.
5496 set dummy $tool_basename; ac_word=$2
5497 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5498 $as_echo_n "checking for $ac_word... " >&6; }
5499 if ${ac_cv_path_BASH+:} false; then :
5500   $as_echo_n "(cached) " >&6
5501 else
5502   case $BASH in
5503   [\\/]* | ?:[\\/]*)
5504   ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
5505   ;;
5506   *)
5507   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5508 for as_dir in $PATH
5509 do
5510   IFS=$as_save_IFS
5511   test -z "$as_dir" && as_dir=.
5512     for ac_exec_ext in '' $ac_executable_extensions; do
5513   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5514     ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
5515     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5516     break 2
5517   fi
5518 done
5519   done
5520 IFS=$as_save_IFS
5521 
5522   ;;
5523 esac
5524 fi
5525 BASH=$ac_cv_path_BASH
5526 if test -n "$BASH"; then
5527   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
5528 $as_echo "$BASH" >&6; }
5529 else
5530   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5531 $as_echo "no" >&6; }
5532 fi
5533 
5534 
5535           if test "x$BASH" = x; then
5536             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5537           fi
5538         else
5539           # Otherwise we believe it is a complete path. Use it as it is.
5540           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BASH=$tool_specified" >&5
5541 $as_echo "$as_me: Will use user supplied tool BASH=$tool_specified" >&6;}
5542           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASH" >&5
5543 $as_echo_n "checking for BASH... " >&6; }
5544           if test ! -x "$tool_specified"; then
5545             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5546 $as_echo "not found" >&6; }
5547             as_fn_error $? "User supplied tool BASH=$tool_specified does not exist or is not executable" "$LINENO" 5
5548           fi
5549           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5550 $as_echo "$tool_specified" >&6; }
5551         fi
5552       fi
5553     fi
5554 
5555   fi
5556 
5557 
5558 
5559   if test "x$BASH" = x; then
5560     as_fn_error $? "Could not find required tool for BASH" "$LINENO" 5
5561   fi
5562 
5563 
5564 
5565 
5566 
5567   # Publish this variable in the help.
5568 
5569 
5570   if [ -z "${CAT+x}" ]; then
5571     # The variable is not set by user, try to locate tool using the code snippet
5572     for ac_prog in cat
5573 do
5574   # Extract the first word of "$ac_prog", so it can be a program name with args.
5575 set dummy $ac_prog; ac_word=$2
5576 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5577 $as_echo_n "checking for $ac_word... " >&6; }
5578 if ${ac_cv_path_CAT+:} false; then :
5579   $as_echo_n "(cached) " >&6
5580 else
5581   case $CAT in
5582   [\\/]* | ?:[\\/]*)
5583   ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
5584   ;;
5585   *)
5586   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5587 for as_dir in $PATH
5588 do
5589   IFS=$as_save_IFS
5590   test -z "$as_dir" && as_dir=.
5591     for ac_exec_ext in '' $ac_executable_extensions; do
5592   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5593     ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
5594     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5595     break 2
5596   fi
5597 done
5598   done
5599 IFS=$as_save_IFS
5600 
5601   ;;
5602 esac
5603 fi
5604 CAT=$ac_cv_path_CAT
5605 if test -n "$CAT"; then
5606   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
5607 $as_echo "$CAT" >&6; }
5608 else
5609   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5610 $as_echo "no" >&6; }
5611 fi
5612 
5613 
5614   test -n "$CAT" && break
5615 done
5616 
5617   else
5618     # The variable is set, but is it from the command line or the environment?
5619 
5620     # Try to remove the string !CAT! from our list.
5621     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CAT!/}
5622     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5623       # If it failed, the variable was not from the command line. Ignore it,
5624       # but warn the user (except for BASH, which is always set by the calling BASH).
5625       if test "xCAT" != xBASH; then
5626         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CAT from the environment. Use command line variables instead." >&5
5627 $as_echo "$as_me: WARNING: Ignoring value of CAT from the environment. Use command line variables instead." >&2;}
5628       fi
5629       # Try to locate tool using the code snippet
5630       for ac_prog in cat
5631 do
5632   # Extract the first word of "$ac_prog", so it can be a program name with args.
5633 set dummy $ac_prog; ac_word=$2
5634 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5635 $as_echo_n "checking for $ac_word... " >&6; }
5636 if ${ac_cv_path_CAT+:} false; then :
5637   $as_echo_n "(cached) " >&6
5638 else
5639   case $CAT in
5640   [\\/]* | ?:[\\/]*)
5641   ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
5642   ;;
5643   *)
5644   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5645 for as_dir in $PATH
5646 do
5647   IFS=$as_save_IFS
5648   test -z "$as_dir" && as_dir=.
5649     for ac_exec_ext in '' $ac_executable_extensions; do
5650   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5651     ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
5652     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5653     break 2
5654   fi
5655 done
5656   done
5657 IFS=$as_save_IFS
5658 
5659   ;;
5660 esac
5661 fi
5662 CAT=$ac_cv_path_CAT
5663 if test -n "$CAT"; then
5664   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
5665 $as_echo "$CAT" >&6; }
5666 else
5667   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5668 $as_echo "no" >&6; }
5669 fi
5670 
5671 
5672   test -n "$CAT" && break
5673 done
5674 
5675     else
5676       # If it succeeded, then it was overridden by the user. We will use it
5677       # for the tool.
5678 
5679       # First remove it from the list of overridden variables, so we can test
5680       # for unknown variables in the end.
5681       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5682 
5683       # Check if we try to supply an empty value
5684       if test "x$CAT" = x; then
5685         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CAT= (no value)" >&5
5686 $as_echo "$as_me: Setting user supplied tool CAT= (no value)" >&6;}
5687         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CAT" >&5
5688 $as_echo_n "checking for CAT... " >&6; }
5689         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
5690 $as_echo "disabled" >&6; }
5691       else
5692         # Check if the provided tool contains a complete path.
5693         tool_specified="$CAT"
5694         tool_basename="${tool_specified##*/}"
5695         if test "x$tool_basename" = "x$tool_specified"; then
5696           # A command without a complete path is provided, search $PATH.
5697           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CAT=$tool_basename" >&5
5698 $as_echo "$as_me: Will search for user supplied tool CAT=$tool_basename" >&6;}
5699           # Extract the first word of "$tool_basename", so it can be a program name with args.
5700 set dummy $tool_basename; ac_word=$2
5701 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5702 $as_echo_n "checking for $ac_word... " >&6; }
5703 if ${ac_cv_path_CAT+:} false; then :
5704   $as_echo_n "(cached) " >&6
5705 else
5706   case $CAT in
5707   [\\/]* | ?:[\\/]*)
5708   ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
5709   ;;
5710   *)
5711   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5712 for as_dir in $PATH
5713 do
5714   IFS=$as_save_IFS
5715   test -z "$as_dir" && as_dir=.
5716     for ac_exec_ext in '' $ac_executable_extensions; do
5717   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5718     ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
5719     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5720     break 2
5721   fi
5722 done
5723   done
5724 IFS=$as_save_IFS
5725 
5726   ;;
5727 esac
5728 fi
5729 CAT=$ac_cv_path_CAT
5730 if test -n "$CAT"; then
5731   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
5732 $as_echo "$CAT" >&6; }
5733 else
5734   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5735 $as_echo "no" >&6; }
5736 fi
5737 
5738 
5739           if test "x$CAT" = x; then
5740             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5741           fi
5742         else
5743           # Otherwise we believe it is a complete path. Use it as it is.
5744           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CAT=$tool_specified" >&5
5745 $as_echo "$as_me: Will use user supplied tool CAT=$tool_specified" >&6;}
5746           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CAT" >&5
5747 $as_echo_n "checking for CAT... " >&6; }
5748           if test ! -x "$tool_specified"; then
5749             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5750 $as_echo "not found" >&6; }
5751             as_fn_error $? "User supplied tool CAT=$tool_specified does not exist or is not executable" "$LINENO" 5
5752           fi
5753           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5754 $as_echo "$tool_specified" >&6; }
5755         fi
5756       fi
5757     fi
5758 
5759   fi
5760 
5761 
5762 
5763   if test "x$CAT" = x; then
5764     as_fn_error $? "Could not find required tool for CAT" "$LINENO" 5
5765   fi
5766 
5767 
5768 
5769 
5770 
5771   # Publish this variable in the help.
5772 
5773 
5774   if [ -z "${CHMOD+x}" ]; then
5775     # The variable is not set by user, try to locate tool using the code snippet
5776     for ac_prog in chmod
5777 do
5778   # Extract the first word of "$ac_prog", so it can be a program name with args.
5779 set dummy $ac_prog; ac_word=$2
5780 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5781 $as_echo_n "checking for $ac_word... " >&6; }
5782 if ${ac_cv_path_CHMOD+:} false; then :
5783   $as_echo_n "(cached) " >&6
5784 else
5785   case $CHMOD in
5786   [\\/]* | ?:[\\/]*)
5787   ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
5788   ;;
5789   *)
5790   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5791 for as_dir in $PATH
5792 do
5793   IFS=$as_save_IFS
5794   test -z "$as_dir" && as_dir=.
5795     for ac_exec_ext in '' $ac_executable_extensions; do
5796   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5797     ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
5798     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5799     break 2
5800   fi
5801 done
5802   done
5803 IFS=$as_save_IFS
5804 
5805   ;;
5806 esac
5807 fi
5808 CHMOD=$ac_cv_path_CHMOD
5809 if test -n "$CHMOD"; then
5810   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
5811 $as_echo "$CHMOD" >&6; }
5812 else
5813   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5814 $as_echo "no" >&6; }
5815 fi
5816 
5817 
5818   test -n "$CHMOD" && break
5819 done
5820 
5821   else
5822     # The variable is set, but is it from the command line or the environment?
5823 
5824     # Try to remove the string !CHMOD! from our list.
5825     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CHMOD!/}
5826     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5827       # If it failed, the variable was not from the command line. Ignore it,
5828       # but warn the user (except for BASH, which is always set by the calling BASH).
5829       if test "xCHMOD" != xBASH; then
5830         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CHMOD from the environment. Use command line variables instead." >&5
5831 $as_echo "$as_me: WARNING: Ignoring value of CHMOD from the environment. Use command line variables instead." >&2;}
5832       fi
5833       # Try to locate tool using the code snippet
5834       for ac_prog in chmod
5835 do
5836   # Extract the first word of "$ac_prog", so it can be a program name with args.
5837 set dummy $ac_prog; ac_word=$2
5838 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5839 $as_echo_n "checking for $ac_word... " >&6; }
5840 if ${ac_cv_path_CHMOD+:} false; then :
5841   $as_echo_n "(cached) " >&6
5842 else
5843   case $CHMOD in
5844   [\\/]* | ?:[\\/]*)
5845   ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
5846   ;;
5847   *)
5848   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5849 for as_dir in $PATH
5850 do
5851   IFS=$as_save_IFS
5852   test -z "$as_dir" && as_dir=.
5853     for ac_exec_ext in '' $ac_executable_extensions; do
5854   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5855     ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
5856     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5857     break 2
5858   fi
5859 done
5860   done
5861 IFS=$as_save_IFS
5862 
5863   ;;
5864 esac
5865 fi
5866 CHMOD=$ac_cv_path_CHMOD
5867 if test -n "$CHMOD"; then
5868   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
5869 $as_echo "$CHMOD" >&6; }
5870 else
5871   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5872 $as_echo "no" >&6; }
5873 fi
5874 
5875 
5876   test -n "$CHMOD" && break
5877 done
5878 
5879     else
5880       # If it succeeded, then it was overridden by the user. We will use it
5881       # for the tool.
5882 
5883       # First remove it from the list of overridden variables, so we can test
5884       # for unknown variables in the end.
5885       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5886 
5887       # Check if we try to supply an empty value
5888       if test "x$CHMOD" = x; then
5889         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CHMOD= (no value)" >&5
5890 $as_echo "$as_me: Setting user supplied tool CHMOD= (no value)" >&6;}
5891         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CHMOD" >&5
5892 $as_echo_n "checking for CHMOD... " >&6; }
5893         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
5894 $as_echo "disabled" >&6; }
5895       else
5896         # Check if the provided tool contains a complete path.
5897         tool_specified="$CHMOD"
5898         tool_basename="${tool_specified##*/}"
5899         if test "x$tool_basename" = "x$tool_specified"; then
5900           # A command without a complete path is provided, search $PATH.
5901           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CHMOD=$tool_basename" >&5
5902 $as_echo "$as_me: Will search for user supplied tool CHMOD=$tool_basename" >&6;}
5903           # Extract the first word of "$tool_basename", so it can be a program name with args.
5904 set dummy $tool_basename; ac_word=$2
5905 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5906 $as_echo_n "checking for $ac_word... " >&6; }
5907 if ${ac_cv_path_CHMOD+:} false; then :
5908   $as_echo_n "(cached) " >&6
5909 else
5910   case $CHMOD in
5911   [\\/]* | ?:[\\/]*)
5912   ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
5913   ;;
5914   *)
5915   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5916 for as_dir in $PATH
5917 do
5918   IFS=$as_save_IFS
5919   test -z "$as_dir" && as_dir=.
5920     for ac_exec_ext in '' $ac_executable_extensions; do
5921   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5922     ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
5923     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5924     break 2
5925   fi
5926 done
5927   done
5928 IFS=$as_save_IFS
5929 
5930   ;;
5931 esac
5932 fi
5933 CHMOD=$ac_cv_path_CHMOD
5934 if test -n "$CHMOD"; then
5935   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
5936 $as_echo "$CHMOD" >&6; }
5937 else
5938   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5939 $as_echo "no" >&6; }
5940 fi
5941 
5942 
5943           if test "x$CHMOD" = x; then
5944             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5945           fi
5946         else
5947           # Otherwise we believe it is a complete path. Use it as it is.
5948           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CHMOD=$tool_specified" >&5
5949 $as_echo "$as_me: Will use user supplied tool CHMOD=$tool_specified" >&6;}
5950           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CHMOD" >&5
5951 $as_echo_n "checking for CHMOD... " >&6; }
5952           if test ! -x "$tool_specified"; then
5953             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5954 $as_echo "not found" >&6; }
5955             as_fn_error $? "User supplied tool CHMOD=$tool_specified does not exist or is not executable" "$LINENO" 5
5956           fi
5957           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5958 $as_echo "$tool_specified" >&6; }
5959         fi
5960       fi
5961     fi
5962 
5963   fi
5964 
5965 
5966 
5967   if test "x$CHMOD" = x; then
5968     as_fn_error $? "Could not find required tool for CHMOD" "$LINENO" 5
5969   fi
5970 
5971 
5972 
5973 
5974 
5975   # Publish this variable in the help.
5976 
5977 
5978   if [ -z "${CMP+x}" ]; then
5979     # The variable is not set by user, try to locate tool using the code snippet
5980     for ac_prog in cmp
5981 do
5982   # Extract the first word of "$ac_prog", so it can be a program name with args.
5983 set dummy $ac_prog; ac_word=$2
5984 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5985 $as_echo_n "checking for $ac_word... " >&6; }
5986 if ${ac_cv_path_CMP+:} false; then :
5987   $as_echo_n "(cached) " >&6
5988 else
5989   case $CMP in
5990   [\\/]* | ?:[\\/]*)
5991   ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
5992   ;;
5993   *)
5994   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5995 for as_dir in $PATH
5996 do
5997   IFS=$as_save_IFS
5998   test -z "$as_dir" && as_dir=.
5999     for ac_exec_ext in '' $ac_executable_extensions; do
6000   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6001     ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
6002     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6003     break 2
6004   fi
6005 done
6006   done
6007 IFS=$as_save_IFS
6008 
6009   ;;
6010 esac
6011 fi
6012 CMP=$ac_cv_path_CMP
6013 if test -n "$CMP"; then
6014   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
6015 $as_echo "$CMP" >&6; }
6016 else
6017   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6018 $as_echo "no" >&6; }
6019 fi
6020 
6021 
6022   test -n "$CMP" && break
6023 done
6024 
6025   else
6026     # The variable is set, but is it from the command line or the environment?
6027 
6028     # Try to remove the string !CMP! from our list.
6029     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CMP!/}
6030     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6031       # If it failed, the variable was not from the command line. Ignore it,
6032       # but warn the user (except for BASH, which is always set by the calling BASH).
6033       if test "xCMP" != xBASH; then
6034         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CMP from the environment. Use command line variables instead." >&5
6035 $as_echo "$as_me: WARNING: Ignoring value of CMP from the environment. Use command line variables instead." >&2;}
6036       fi
6037       # Try to locate tool using the code snippet
6038       for ac_prog in cmp
6039 do
6040   # Extract the first word of "$ac_prog", so it can be a program name with args.
6041 set dummy $ac_prog; ac_word=$2
6042 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6043 $as_echo_n "checking for $ac_word... " >&6; }
6044 if ${ac_cv_path_CMP+:} false; then :
6045   $as_echo_n "(cached) " >&6
6046 else
6047   case $CMP in
6048   [\\/]* | ?:[\\/]*)
6049   ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
6050   ;;
6051   *)
6052   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6053 for as_dir in $PATH
6054 do
6055   IFS=$as_save_IFS
6056   test -z "$as_dir" && as_dir=.
6057     for ac_exec_ext in '' $ac_executable_extensions; do
6058   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6059     ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
6060     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6061     break 2
6062   fi
6063 done
6064   done
6065 IFS=$as_save_IFS
6066 
6067   ;;
6068 esac
6069 fi
6070 CMP=$ac_cv_path_CMP
6071 if test -n "$CMP"; then
6072   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
6073 $as_echo "$CMP" >&6; }
6074 else
6075   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6076 $as_echo "no" >&6; }
6077 fi
6078 
6079 
6080   test -n "$CMP" && break
6081 done
6082 
6083     else
6084       # If it succeeded, then it was overridden by the user. We will use it
6085       # for the tool.
6086 
6087       # First remove it from the list of overridden variables, so we can test
6088       # for unknown variables in the end.
6089       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6090 
6091       # Check if we try to supply an empty value
6092       if test "x$CMP" = x; then
6093         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CMP= (no value)" >&5
6094 $as_echo "$as_me: Setting user supplied tool CMP= (no value)" >&6;}
6095         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CMP" >&5
6096 $as_echo_n "checking for CMP... " >&6; }
6097         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
6098 $as_echo "disabled" >&6; }
6099       else
6100         # Check if the provided tool contains a complete path.
6101         tool_specified="$CMP"
6102         tool_basename="${tool_specified##*/}"
6103         if test "x$tool_basename" = "x$tool_specified"; then
6104           # A command without a complete path is provided, search $PATH.
6105           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CMP=$tool_basename" >&5
6106 $as_echo "$as_me: Will search for user supplied tool CMP=$tool_basename" >&6;}
6107           # Extract the first word of "$tool_basename", so it can be a program name with args.
6108 set dummy $tool_basename; ac_word=$2
6109 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6110 $as_echo_n "checking for $ac_word... " >&6; }
6111 if ${ac_cv_path_CMP+:} false; then :
6112   $as_echo_n "(cached) " >&6
6113 else
6114   case $CMP in
6115   [\\/]* | ?:[\\/]*)
6116   ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
6117   ;;
6118   *)
6119   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6120 for as_dir in $PATH
6121 do
6122   IFS=$as_save_IFS
6123   test -z "$as_dir" && as_dir=.
6124     for ac_exec_ext in '' $ac_executable_extensions; do
6125   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6126     ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
6127     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6128     break 2
6129   fi
6130 done
6131   done
6132 IFS=$as_save_IFS
6133 
6134   ;;
6135 esac
6136 fi
6137 CMP=$ac_cv_path_CMP
6138 if test -n "$CMP"; then
6139   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
6140 $as_echo "$CMP" >&6; }
6141 else
6142   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6143 $as_echo "no" >&6; }
6144 fi
6145 
6146 
6147           if test "x$CMP" = x; then
6148             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6149           fi
6150         else
6151           # Otherwise we believe it is a complete path. Use it as it is.
6152           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CMP=$tool_specified" >&5
6153 $as_echo "$as_me: Will use user supplied tool CMP=$tool_specified" >&6;}
6154           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CMP" >&5
6155 $as_echo_n "checking for CMP... " >&6; }
6156           if test ! -x "$tool_specified"; then
6157             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6158 $as_echo "not found" >&6; }
6159             as_fn_error $? "User supplied tool CMP=$tool_specified does not exist or is not executable" "$LINENO" 5
6160           fi
6161           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6162 $as_echo "$tool_specified" >&6; }
6163         fi
6164       fi
6165     fi
6166 
6167   fi
6168 
6169 
6170 
6171   if test "x$CMP" = x; then
6172     as_fn_error $? "Could not find required tool for CMP" "$LINENO" 5
6173   fi
6174 
6175 
6176 
6177 
6178 
6179   # Publish this variable in the help.
6180 
6181 
6182   if [ -z "${COMM+x}" ]; then
6183     # The variable is not set by user, try to locate tool using the code snippet
6184     for ac_prog in comm
6185 do
6186   # Extract the first word of "$ac_prog", so it can be a program name with args.
6187 set dummy $ac_prog; ac_word=$2
6188 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6189 $as_echo_n "checking for $ac_word... " >&6; }
6190 if ${ac_cv_path_COMM+:} false; then :
6191   $as_echo_n "(cached) " >&6
6192 else
6193   case $COMM in
6194   [\\/]* | ?:[\\/]*)
6195   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
6196   ;;
6197   *)
6198   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6199 for as_dir in $PATH
6200 do
6201   IFS=$as_save_IFS
6202   test -z "$as_dir" && as_dir=.
6203     for ac_exec_ext in '' $ac_executable_extensions; do
6204   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6205     ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
6206     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6207     break 2
6208   fi
6209 done
6210   done
6211 IFS=$as_save_IFS
6212 
6213   ;;
6214 esac
6215 fi
6216 COMM=$ac_cv_path_COMM
6217 if test -n "$COMM"; then
6218   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
6219 $as_echo "$COMM" >&6; }
6220 else
6221   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6222 $as_echo "no" >&6; }
6223 fi
6224 
6225 
6226   test -n "$COMM" && break
6227 done
6228 
6229   else
6230     # The variable is set, but is it from the command line or the environment?
6231 
6232     # Try to remove the string !COMM! from our list.
6233     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!COMM!/}
6234     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6235       # If it failed, the variable was not from the command line. Ignore it,
6236       # but warn the user (except for BASH, which is always set by the calling BASH).
6237       if test "xCOMM" != xBASH; then
6238         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&5
6239 $as_echo "$as_me: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&2;}
6240       fi
6241       # Try to locate tool using the code snippet
6242       for ac_prog in comm
6243 do
6244   # Extract the first word of "$ac_prog", so it can be a program name with args.
6245 set dummy $ac_prog; ac_word=$2
6246 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6247 $as_echo_n "checking for $ac_word... " >&6; }
6248 if ${ac_cv_path_COMM+:} false; then :
6249   $as_echo_n "(cached) " >&6
6250 else
6251   case $COMM in
6252   [\\/]* | ?:[\\/]*)
6253   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
6254   ;;
6255   *)
6256   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6257 for as_dir in $PATH
6258 do
6259   IFS=$as_save_IFS
6260   test -z "$as_dir" && as_dir=.
6261     for ac_exec_ext in '' $ac_executable_extensions; do
6262   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6263     ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
6264     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6265     break 2
6266   fi
6267 done
6268   done
6269 IFS=$as_save_IFS
6270 
6271   ;;
6272 esac
6273 fi
6274 COMM=$ac_cv_path_COMM
6275 if test -n "$COMM"; then
6276   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
6277 $as_echo "$COMM" >&6; }
6278 else
6279   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6280 $as_echo "no" >&6; }
6281 fi
6282 
6283 
6284   test -n "$COMM" && break
6285 done
6286 
6287     else
6288       # If it succeeded, then it was overridden by the user. We will use it
6289       # for the tool.
6290 
6291       # First remove it from the list of overridden variables, so we can test
6292       # for unknown variables in the end.
6293       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6294 
6295       # Check if we try to supply an empty value
6296       if test "x$COMM" = x; then
6297         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool COMM= (no value)" >&5
6298 $as_echo "$as_me: Setting user supplied tool COMM= (no value)" >&6;}
6299         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for COMM" >&5
6300 $as_echo_n "checking for COMM... " >&6; }
6301         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
6302 $as_echo "disabled" >&6; }
6303       else
6304         # Check if the provided tool contains a complete path.
6305         tool_specified="$COMM"
6306         tool_basename="${tool_specified##*/}"
6307         if test "x$tool_basename" = "x$tool_specified"; then
6308           # A command without a complete path is provided, search $PATH.
6309           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool COMM=$tool_basename" >&5
6310 $as_echo "$as_me: Will search for user supplied tool COMM=$tool_basename" >&6;}
6311           # Extract the first word of "$tool_basename", so it can be a program name with args.
6312 set dummy $tool_basename; ac_word=$2
6313 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6314 $as_echo_n "checking for $ac_word... " >&6; }
6315 if ${ac_cv_path_COMM+:} false; then :
6316   $as_echo_n "(cached) " >&6
6317 else
6318   case $COMM in
6319   [\\/]* | ?:[\\/]*)
6320   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
6321   ;;
6322   *)
6323   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6324 for as_dir in $PATH
6325 do
6326   IFS=$as_save_IFS
6327   test -z "$as_dir" && as_dir=.
6328     for ac_exec_ext in '' $ac_executable_extensions; do
6329   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6330     ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
6331     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6332     break 2
6333   fi
6334 done
6335   done
6336 IFS=$as_save_IFS
6337 
6338   ;;
6339 esac
6340 fi
6341 COMM=$ac_cv_path_COMM
6342 if test -n "$COMM"; then
6343   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
6344 $as_echo "$COMM" >&6; }
6345 else
6346   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6347 $as_echo "no" >&6; }
6348 fi
6349 
6350 
6351           if test "x$COMM" = x; then
6352             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6353           fi
6354         else
6355           # Otherwise we believe it is a complete path. Use it as it is.
6356           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool COMM=$tool_specified" >&5
6357 $as_echo "$as_me: Will use user supplied tool COMM=$tool_specified" >&6;}
6358           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for COMM" >&5
6359 $as_echo_n "checking for COMM... " >&6; }
6360           if test ! -x "$tool_specified"; then
6361             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6362 $as_echo "not found" >&6; }
6363             as_fn_error $? "User supplied tool COMM=$tool_specified does not exist or is not executable" "$LINENO" 5
6364           fi
6365           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6366 $as_echo "$tool_specified" >&6; }
6367         fi
6368       fi
6369     fi
6370 
6371   fi
6372 
6373 
6374 
6375   if test "x$COMM" = x; then
6376     as_fn_error $? "Could not find required tool for COMM" "$LINENO" 5
6377   fi
6378 
6379 
6380 
6381 
6382 
6383   # Publish this variable in the help.
6384 
6385 
6386   if [ -z "${CP+x}" ]; then
6387     # The variable is not set by user, try to locate tool using the code snippet
6388     for ac_prog in cp
6389 do
6390   # Extract the first word of "$ac_prog", so it can be a program name with args.
6391 set dummy $ac_prog; ac_word=$2
6392 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6393 $as_echo_n "checking for $ac_word... " >&6; }
6394 if ${ac_cv_path_CP+:} false; then :
6395   $as_echo_n "(cached) " >&6
6396 else
6397   case $CP in
6398   [\\/]* | ?:[\\/]*)
6399   ac_cv_path_CP="$CP" # Let the user override the test with a path.
6400   ;;
6401   *)
6402   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6403 for as_dir in $PATH
6404 do
6405   IFS=$as_save_IFS
6406   test -z "$as_dir" && as_dir=.
6407     for ac_exec_ext in '' $ac_executable_extensions; do
6408   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6409     ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
6410     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6411     break 2
6412   fi
6413 done
6414   done
6415 IFS=$as_save_IFS
6416 
6417   ;;
6418 esac
6419 fi
6420 CP=$ac_cv_path_CP
6421 if test -n "$CP"; then
6422   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
6423 $as_echo "$CP" >&6; }
6424 else
6425   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6426 $as_echo "no" >&6; }
6427 fi
6428 
6429 
6430   test -n "$CP" && break
6431 done
6432 
6433   else
6434     # The variable is set, but is it from the command line or the environment?
6435 
6436     # Try to remove the string !CP! from our list.
6437     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CP!/}
6438     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6439       # If it failed, the variable was not from the command line. Ignore it,
6440       # but warn the user (except for BASH, which is always set by the calling BASH).
6441       if test "xCP" != xBASH; then
6442         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CP from the environment. Use command line variables instead." >&5
6443 $as_echo "$as_me: WARNING: Ignoring value of CP from the environment. Use command line variables instead." >&2;}
6444       fi
6445       # Try to locate tool using the code snippet
6446       for ac_prog in cp
6447 do
6448   # Extract the first word of "$ac_prog", so it can be a program name with args.
6449 set dummy $ac_prog; ac_word=$2
6450 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6451 $as_echo_n "checking for $ac_word... " >&6; }
6452 if ${ac_cv_path_CP+:} false; then :
6453   $as_echo_n "(cached) " >&6
6454 else
6455   case $CP in
6456   [\\/]* | ?:[\\/]*)
6457   ac_cv_path_CP="$CP" # Let the user override the test with a path.
6458   ;;
6459   *)
6460   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6461 for as_dir in $PATH
6462 do
6463   IFS=$as_save_IFS
6464   test -z "$as_dir" && as_dir=.
6465     for ac_exec_ext in '' $ac_executable_extensions; do
6466   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6467     ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
6468     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6469     break 2
6470   fi
6471 done
6472   done
6473 IFS=$as_save_IFS
6474 
6475   ;;
6476 esac
6477 fi
6478 CP=$ac_cv_path_CP
6479 if test -n "$CP"; then
6480   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
6481 $as_echo "$CP" >&6; }
6482 else
6483   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6484 $as_echo "no" >&6; }
6485 fi
6486 
6487 
6488   test -n "$CP" && break
6489 done
6490 
6491     else
6492       # If it succeeded, then it was overridden by the user. We will use it
6493       # for the tool.
6494 
6495       # First remove it from the list of overridden variables, so we can test
6496       # for unknown variables in the end.
6497       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6498 
6499       # Check if we try to supply an empty value
6500       if test "x$CP" = x; then
6501         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CP= (no value)" >&5
6502 $as_echo "$as_me: Setting user supplied tool CP= (no value)" >&6;}
6503         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CP" >&5
6504 $as_echo_n "checking for CP... " >&6; }
6505         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
6506 $as_echo "disabled" >&6; }
6507       else
6508         # Check if the provided tool contains a complete path.
6509         tool_specified="$CP"
6510         tool_basename="${tool_specified##*/}"
6511         if test "x$tool_basename" = "x$tool_specified"; then
6512           # A command without a complete path is provided, search $PATH.
6513           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CP=$tool_basename" >&5
6514 $as_echo "$as_me: Will search for user supplied tool CP=$tool_basename" >&6;}
6515           # Extract the first word of "$tool_basename", so it can be a program name with args.
6516 set dummy $tool_basename; ac_word=$2
6517 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6518 $as_echo_n "checking for $ac_word... " >&6; }
6519 if ${ac_cv_path_CP+:} false; then :
6520   $as_echo_n "(cached) " >&6
6521 else
6522   case $CP in
6523   [\\/]* | ?:[\\/]*)
6524   ac_cv_path_CP="$CP" # Let the user override the test with a path.
6525   ;;
6526   *)
6527   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6528 for as_dir in $PATH
6529 do
6530   IFS=$as_save_IFS
6531   test -z "$as_dir" && as_dir=.
6532     for ac_exec_ext in '' $ac_executable_extensions; do
6533   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6534     ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
6535     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6536     break 2
6537   fi
6538 done
6539   done
6540 IFS=$as_save_IFS
6541 
6542   ;;
6543 esac
6544 fi
6545 CP=$ac_cv_path_CP
6546 if test -n "$CP"; then
6547   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
6548 $as_echo "$CP" >&6; }
6549 else
6550   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6551 $as_echo "no" >&6; }
6552 fi
6553 
6554 
6555           if test "x$CP" = x; then
6556             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6557           fi
6558         else
6559           # Otherwise we believe it is a complete path. Use it as it is.
6560           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CP=$tool_specified" >&5
6561 $as_echo "$as_me: Will use user supplied tool CP=$tool_specified" >&6;}
6562           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CP" >&5
6563 $as_echo_n "checking for CP... " >&6; }
6564           if test ! -x "$tool_specified"; then
6565             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6566 $as_echo "not found" >&6; }
6567             as_fn_error $? "User supplied tool CP=$tool_specified does not exist or is not executable" "$LINENO" 5
6568           fi
6569           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6570 $as_echo "$tool_specified" >&6; }
6571         fi
6572       fi
6573     fi
6574 
6575   fi
6576 
6577 
6578 
6579   if test "x$CP" = x; then
6580     as_fn_error $? "Could not find required tool for CP" "$LINENO" 5
6581   fi
6582 
6583 
6584 
6585 
6586 
6587   # Publish this variable in the help.
6588 
6589 
6590   if [ -z "${CUT+x}" ]; then
6591     # The variable is not set by user, try to locate tool using the code snippet
6592     for ac_prog in cut
6593 do
6594   # Extract the first word of "$ac_prog", so it can be a program name with args.
6595 set dummy $ac_prog; ac_word=$2
6596 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6597 $as_echo_n "checking for $ac_word... " >&6; }
6598 if ${ac_cv_path_CUT+:} false; then :
6599   $as_echo_n "(cached) " >&6
6600 else
6601   case $CUT in
6602   [\\/]* | ?:[\\/]*)
6603   ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
6604   ;;
6605   *)
6606   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6607 for as_dir in $PATH
6608 do
6609   IFS=$as_save_IFS
6610   test -z "$as_dir" && as_dir=.
6611     for ac_exec_ext in '' $ac_executable_extensions; do
6612   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6613     ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
6614     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6615     break 2
6616   fi
6617 done
6618   done
6619 IFS=$as_save_IFS
6620 
6621   ;;
6622 esac
6623 fi
6624 CUT=$ac_cv_path_CUT
6625 if test -n "$CUT"; then
6626   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
6627 $as_echo "$CUT" >&6; }
6628 else
6629   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6630 $as_echo "no" >&6; }
6631 fi
6632 
6633 
6634   test -n "$CUT" && break
6635 done
6636 
6637   else
6638     # The variable is set, but is it from the command line or the environment?
6639 
6640     # Try to remove the string !CUT! from our list.
6641     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CUT!/}
6642     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6643       # If it failed, the variable was not from the command line. Ignore it,
6644       # but warn the user (except for BASH, which is always set by the calling BASH).
6645       if test "xCUT" != xBASH; then
6646         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CUT from the environment. Use command line variables instead." >&5
6647 $as_echo "$as_me: WARNING: Ignoring value of CUT from the environment. Use command line variables instead." >&2;}
6648       fi
6649       # Try to locate tool using the code snippet
6650       for ac_prog in cut
6651 do
6652   # Extract the first word of "$ac_prog", so it can be a program name with args.
6653 set dummy $ac_prog; ac_word=$2
6654 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6655 $as_echo_n "checking for $ac_word... " >&6; }
6656 if ${ac_cv_path_CUT+:} false; then :
6657   $as_echo_n "(cached) " >&6
6658 else
6659   case $CUT in
6660   [\\/]* | ?:[\\/]*)
6661   ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
6662   ;;
6663   *)
6664   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6665 for as_dir in $PATH
6666 do
6667   IFS=$as_save_IFS
6668   test -z "$as_dir" && as_dir=.
6669     for ac_exec_ext in '' $ac_executable_extensions; do
6670   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6671     ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
6672     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6673     break 2
6674   fi
6675 done
6676   done
6677 IFS=$as_save_IFS
6678 
6679   ;;
6680 esac
6681 fi
6682 CUT=$ac_cv_path_CUT
6683 if test -n "$CUT"; then
6684   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
6685 $as_echo "$CUT" >&6; }
6686 else
6687   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6688 $as_echo "no" >&6; }
6689 fi
6690 
6691 
6692   test -n "$CUT" && break
6693 done
6694 
6695     else
6696       # If it succeeded, then it was overridden by the user. We will use it
6697       # for the tool.
6698 
6699       # First remove it from the list of overridden variables, so we can test
6700       # for unknown variables in the end.
6701       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6702 
6703       # Check if we try to supply an empty value
6704       if test "x$CUT" = x; then
6705         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CUT= (no value)" >&5
6706 $as_echo "$as_me: Setting user supplied tool CUT= (no value)" >&6;}
6707         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CUT" >&5
6708 $as_echo_n "checking for CUT... " >&6; }
6709         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
6710 $as_echo "disabled" >&6; }
6711       else
6712         # Check if the provided tool contains a complete path.
6713         tool_specified="$CUT"
6714         tool_basename="${tool_specified##*/}"
6715         if test "x$tool_basename" = "x$tool_specified"; then
6716           # A command without a complete path is provided, search $PATH.
6717           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CUT=$tool_basename" >&5
6718 $as_echo "$as_me: Will search for user supplied tool CUT=$tool_basename" >&6;}
6719           # Extract the first word of "$tool_basename", so it can be a program name with args.
6720 set dummy $tool_basename; ac_word=$2
6721 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6722 $as_echo_n "checking for $ac_word... " >&6; }
6723 if ${ac_cv_path_CUT+:} false; then :
6724   $as_echo_n "(cached) " >&6
6725 else
6726   case $CUT in
6727   [\\/]* | ?:[\\/]*)
6728   ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
6729   ;;
6730   *)
6731   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6732 for as_dir in $PATH
6733 do
6734   IFS=$as_save_IFS
6735   test -z "$as_dir" && as_dir=.
6736     for ac_exec_ext in '' $ac_executable_extensions; do
6737   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6738     ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
6739     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6740     break 2
6741   fi
6742 done
6743   done
6744 IFS=$as_save_IFS
6745 
6746   ;;
6747 esac
6748 fi
6749 CUT=$ac_cv_path_CUT
6750 if test -n "$CUT"; then
6751   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
6752 $as_echo "$CUT" >&6; }
6753 else
6754   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6755 $as_echo "no" >&6; }
6756 fi
6757 
6758 
6759           if test "x$CUT" = x; then
6760             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6761           fi
6762         else
6763           # Otherwise we believe it is a complete path. Use it as it is.
6764           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CUT=$tool_specified" >&5
6765 $as_echo "$as_me: Will use user supplied tool CUT=$tool_specified" >&6;}
6766           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CUT" >&5
6767 $as_echo_n "checking for CUT... " >&6; }
6768           if test ! -x "$tool_specified"; then
6769             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6770 $as_echo "not found" >&6; }
6771             as_fn_error $? "User supplied tool CUT=$tool_specified does not exist or is not executable" "$LINENO" 5
6772           fi
6773           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6774 $as_echo "$tool_specified" >&6; }
6775         fi
6776       fi
6777     fi
6778 
6779   fi
6780 
6781 
6782 
6783   if test "x$CUT" = x; then
6784     as_fn_error $? "Could not find required tool for CUT" "$LINENO" 5
6785   fi
6786 
6787 
6788 
6789 
6790 
6791   # Publish this variable in the help.
6792 
6793 
6794   if [ -z "${DATE+x}" ]; then
6795     # The variable is not set by user, try to locate tool using the code snippet
6796     for ac_prog in date
6797 do
6798   # Extract the first word of "$ac_prog", so it can be a program name with args.
6799 set dummy $ac_prog; ac_word=$2
6800 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6801 $as_echo_n "checking for $ac_word... " >&6; }
6802 if ${ac_cv_path_DATE+:} false; then :
6803   $as_echo_n "(cached) " >&6
6804 else
6805   case $DATE in
6806   [\\/]* | ?:[\\/]*)
6807   ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
6808   ;;
6809   *)
6810   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6811 for as_dir in $PATH
6812 do
6813   IFS=$as_save_IFS
6814   test -z "$as_dir" && as_dir=.
6815     for ac_exec_ext in '' $ac_executable_extensions; do
6816   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6817     ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
6818     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6819     break 2
6820   fi
6821 done
6822   done
6823 IFS=$as_save_IFS
6824 
6825   ;;
6826 esac
6827 fi
6828 DATE=$ac_cv_path_DATE
6829 if test -n "$DATE"; then
6830   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
6831 $as_echo "$DATE" >&6; }
6832 else
6833   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6834 $as_echo "no" >&6; }
6835 fi
6836 
6837 
6838   test -n "$DATE" && break
6839 done
6840 
6841   else
6842     # The variable is set, but is it from the command line or the environment?
6843 
6844     # Try to remove the string !DATE! from our list.
6845     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DATE!/}
6846     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6847       # If it failed, the variable was not from the command line. Ignore it,
6848       # but warn the user (except for BASH, which is always set by the calling BASH).
6849       if test "xDATE" != xBASH; then
6850         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DATE from the environment. Use command line variables instead." >&5
6851 $as_echo "$as_me: WARNING: Ignoring value of DATE from the environment. Use command line variables instead." >&2;}
6852       fi
6853       # Try to locate tool using the code snippet
6854       for ac_prog in date
6855 do
6856   # Extract the first word of "$ac_prog", so it can be a program name with args.
6857 set dummy $ac_prog; ac_word=$2
6858 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6859 $as_echo_n "checking for $ac_word... " >&6; }
6860 if ${ac_cv_path_DATE+:} false; then :
6861   $as_echo_n "(cached) " >&6
6862 else
6863   case $DATE in
6864   [\\/]* | ?:[\\/]*)
6865   ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
6866   ;;
6867   *)
6868   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6869 for as_dir in $PATH
6870 do
6871   IFS=$as_save_IFS
6872   test -z "$as_dir" && as_dir=.
6873     for ac_exec_ext in '' $ac_executable_extensions; do
6874   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6875     ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
6876     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6877     break 2
6878   fi
6879 done
6880   done
6881 IFS=$as_save_IFS
6882 
6883   ;;
6884 esac
6885 fi
6886 DATE=$ac_cv_path_DATE
6887 if test -n "$DATE"; then
6888   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
6889 $as_echo "$DATE" >&6; }
6890 else
6891   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6892 $as_echo "no" >&6; }
6893 fi
6894 
6895 
6896   test -n "$DATE" && break
6897 done
6898 
6899     else
6900       # If it succeeded, then it was overridden by the user. We will use it
6901       # for the tool.
6902 
6903       # First remove it from the list of overridden variables, so we can test
6904       # for unknown variables in the end.
6905       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6906 
6907       # Check if we try to supply an empty value
6908       if test "x$DATE" = x; then
6909         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool DATE= (no value)" >&5
6910 $as_echo "$as_me: Setting user supplied tool DATE= (no value)" >&6;}
6911         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DATE" >&5
6912 $as_echo_n "checking for DATE... " >&6; }
6913         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
6914 $as_echo "disabled" >&6; }
6915       else
6916         # Check if the provided tool contains a complete path.
6917         tool_specified="$DATE"
6918         tool_basename="${tool_specified##*/}"
6919         if test "x$tool_basename" = "x$tool_specified"; then
6920           # A command without a complete path is provided, search $PATH.
6921           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DATE=$tool_basename" >&5
6922 $as_echo "$as_me: Will search for user supplied tool DATE=$tool_basename" >&6;}
6923           # Extract the first word of "$tool_basename", so it can be a program name with args.
6924 set dummy $tool_basename; ac_word=$2
6925 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6926 $as_echo_n "checking for $ac_word... " >&6; }
6927 if ${ac_cv_path_DATE+:} false; then :
6928   $as_echo_n "(cached) " >&6
6929 else
6930   case $DATE in
6931   [\\/]* | ?:[\\/]*)
6932   ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
6933   ;;
6934   *)
6935   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6936 for as_dir in $PATH
6937 do
6938   IFS=$as_save_IFS
6939   test -z "$as_dir" && as_dir=.
6940     for ac_exec_ext in '' $ac_executable_extensions; do
6941   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6942     ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
6943     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6944     break 2
6945   fi
6946 done
6947   done
6948 IFS=$as_save_IFS
6949 
6950   ;;
6951 esac
6952 fi
6953 DATE=$ac_cv_path_DATE
6954 if test -n "$DATE"; then
6955   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
6956 $as_echo "$DATE" >&6; }
6957 else
6958   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6959 $as_echo "no" >&6; }
6960 fi
6961 
6962 
6963           if test "x$DATE" = x; then
6964             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6965           fi
6966         else
6967           # Otherwise we believe it is a complete path. Use it as it is.
6968           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DATE=$tool_specified" >&5
6969 $as_echo "$as_me: Will use user supplied tool DATE=$tool_specified" >&6;}
6970           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DATE" >&5
6971 $as_echo_n "checking for DATE... " >&6; }
6972           if test ! -x "$tool_specified"; then
6973             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6974 $as_echo "not found" >&6; }
6975             as_fn_error $? "User supplied tool DATE=$tool_specified does not exist or is not executable" "$LINENO" 5
6976           fi
6977           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6978 $as_echo "$tool_specified" >&6; }
6979         fi
6980       fi
6981     fi
6982 
6983   fi
6984 
6985 
6986 
6987   if test "x$DATE" = x; then
6988     as_fn_error $? "Could not find required tool for DATE" "$LINENO" 5
6989   fi
6990 
6991 
6992 
6993 
6994 
6995   # Publish this variable in the help.
6996 
6997 
6998   if [ -z "${DIFF+x}" ]; then
6999     # The variable is not set by user, try to locate tool using the code snippet
7000     for ac_prog in gdiff diff
7001 do
7002   # Extract the first word of "$ac_prog", so it can be a program name with args.
7003 set dummy $ac_prog; ac_word=$2
7004 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7005 $as_echo_n "checking for $ac_word... " >&6; }
7006 if ${ac_cv_path_DIFF+:} false; then :
7007   $as_echo_n "(cached) " >&6
7008 else
7009   case $DIFF in
7010   [\\/]* | ?:[\\/]*)
7011   ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
7012   ;;
7013   *)
7014   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7015 for as_dir in $PATH
7016 do
7017   IFS=$as_save_IFS
7018   test -z "$as_dir" && as_dir=.
7019     for ac_exec_ext in '' $ac_executable_extensions; do
7020   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7021     ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
7022     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7023     break 2
7024   fi
7025 done
7026   done
7027 IFS=$as_save_IFS
7028 
7029   ;;
7030 esac
7031 fi
7032 DIFF=$ac_cv_path_DIFF
7033 if test -n "$DIFF"; then
7034   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
7035 $as_echo "$DIFF" >&6; }
7036 else
7037   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7038 $as_echo "no" >&6; }
7039 fi
7040 
7041 
7042   test -n "$DIFF" && break
7043 done
7044 
7045   else
7046     # The variable is set, but is it from the command line or the environment?
7047 
7048     # Try to remove the string !DIFF! from our list.
7049     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DIFF!/}
7050     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7051       # If it failed, the variable was not from the command line. Ignore it,
7052       # but warn the user (except for BASH, which is always set by the calling BASH).
7053       if test "xDIFF" != xBASH; then
7054         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DIFF from the environment. Use command line variables instead." >&5
7055 $as_echo "$as_me: WARNING: Ignoring value of DIFF from the environment. Use command line variables instead." >&2;}
7056       fi
7057       # Try to locate tool using the code snippet
7058       for ac_prog in gdiff diff
7059 do
7060   # Extract the first word of "$ac_prog", so it can be a program name with args.
7061 set dummy $ac_prog; ac_word=$2
7062 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7063 $as_echo_n "checking for $ac_word... " >&6; }
7064 if ${ac_cv_path_DIFF+:} false; then :
7065   $as_echo_n "(cached) " >&6
7066 else
7067   case $DIFF in
7068   [\\/]* | ?:[\\/]*)
7069   ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
7070   ;;
7071   *)
7072   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7073 for as_dir in $PATH
7074 do
7075   IFS=$as_save_IFS
7076   test -z "$as_dir" && as_dir=.
7077     for ac_exec_ext in '' $ac_executable_extensions; do
7078   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7079     ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
7080     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7081     break 2
7082   fi
7083 done
7084   done
7085 IFS=$as_save_IFS
7086 
7087   ;;
7088 esac
7089 fi
7090 DIFF=$ac_cv_path_DIFF
7091 if test -n "$DIFF"; then
7092   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
7093 $as_echo "$DIFF" >&6; }
7094 else
7095   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7096 $as_echo "no" >&6; }
7097 fi
7098 
7099 
7100   test -n "$DIFF" && break
7101 done
7102 
7103     else
7104       # If it succeeded, then it was overridden by the user. We will use it
7105       # for the tool.
7106 
7107       # First remove it from the list of overridden variables, so we can test
7108       # for unknown variables in the end.
7109       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7110 
7111       # Check if we try to supply an empty value
7112       if test "x$DIFF" = x; then
7113         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool DIFF= (no value)" >&5
7114 $as_echo "$as_me: Setting user supplied tool DIFF= (no value)" >&6;}
7115         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIFF" >&5
7116 $as_echo_n "checking for DIFF... " >&6; }
7117         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
7118 $as_echo "disabled" >&6; }
7119       else
7120         # Check if the provided tool contains a complete path.
7121         tool_specified="$DIFF"
7122         tool_basename="${tool_specified##*/}"
7123         if test "x$tool_basename" = "x$tool_specified"; then
7124           # A command without a complete path is provided, search $PATH.
7125           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DIFF=$tool_basename" >&5
7126 $as_echo "$as_me: Will search for user supplied tool DIFF=$tool_basename" >&6;}
7127           # Extract the first word of "$tool_basename", so it can be a program name with args.
7128 set dummy $tool_basename; ac_word=$2
7129 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7130 $as_echo_n "checking for $ac_word... " >&6; }
7131 if ${ac_cv_path_DIFF+:} false; then :
7132   $as_echo_n "(cached) " >&6
7133 else
7134   case $DIFF in
7135   [\\/]* | ?:[\\/]*)
7136   ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
7137   ;;
7138   *)
7139   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7140 for as_dir in $PATH
7141 do
7142   IFS=$as_save_IFS
7143   test -z "$as_dir" && as_dir=.
7144     for ac_exec_ext in '' $ac_executable_extensions; do
7145   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7146     ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
7147     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7148     break 2
7149   fi
7150 done
7151   done
7152 IFS=$as_save_IFS
7153 
7154   ;;
7155 esac
7156 fi
7157 DIFF=$ac_cv_path_DIFF
7158 if test -n "$DIFF"; then
7159   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
7160 $as_echo "$DIFF" >&6; }
7161 else
7162   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7163 $as_echo "no" >&6; }
7164 fi
7165 
7166 
7167           if test "x$DIFF" = x; then
7168             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7169           fi
7170         else
7171           # Otherwise we believe it is a complete path. Use it as it is.
7172           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DIFF=$tool_specified" >&5
7173 $as_echo "$as_me: Will use user supplied tool DIFF=$tool_specified" >&6;}
7174           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIFF" >&5
7175 $as_echo_n "checking for DIFF... " >&6; }
7176           if test ! -x "$tool_specified"; then
7177             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7178 $as_echo "not found" >&6; }
7179             as_fn_error $? "User supplied tool DIFF=$tool_specified does not exist or is not executable" "$LINENO" 5
7180           fi
7181           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7182 $as_echo "$tool_specified" >&6; }
7183         fi
7184       fi
7185     fi
7186 
7187   fi
7188 
7189 
7190 
7191   if test "x$DIFF" = x; then
7192     as_fn_error $? "Could not find required tool for DIFF" "$LINENO" 5
7193   fi
7194 
7195 
7196 
7197 
7198 
7199   # Publish this variable in the help.
7200 
7201 
7202   if [ -z "${DIRNAME+x}" ]; then
7203     # The variable is not set by user, try to locate tool using the code snippet
7204     for ac_prog in dirname
7205 do
7206   # Extract the first word of "$ac_prog", so it can be a program name with args.
7207 set dummy $ac_prog; ac_word=$2
7208 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7209 $as_echo_n "checking for $ac_word... " >&6; }
7210 if ${ac_cv_path_DIRNAME+:} false; then :
7211   $as_echo_n "(cached) " >&6
7212 else
7213   case $DIRNAME in
7214   [\\/]* | ?:[\\/]*)
7215   ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
7216   ;;
7217   *)
7218   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7219 for as_dir in $PATH
7220 do
7221   IFS=$as_save_IFS
7222   test -z "$as_dir" && as_dir=.
7223     for ac_exec_ext in '' $ac_executable_extensions; do
7224   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7225     ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
7226     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7227     break 2
7228   fi
7229 done
7230   done
7231 IFS=$as_save_IFS
7232 
7233   ;;
7234 esac
7235 fi
7236 DIRNAME=$ac_cv_path_DIRNAME
7237 if test -n "$DIRNAME"; then
7238   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
7239 $as_echo "$DIRNAME" >&6; }
7240 else
7241   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7242 $as_echo "no" >&6; }
7243 fi
7244 
7245 
7246   test -n "$DIRNAME" && break
7247 done
7248 
7249   else
7250     # The variable is set, but is it from the command line or the environment?
7251 
7252     # Try to remove the string !DIRNAME! from our list.
7253     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DIRNAME!/}
7254     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7255       # If it failed, the variable was not from the command line. Ignore it,
7256       # but warn the user (except for BASH, which is always set by the calling BASH).
7257       if test "xDIRNAME" != xBASH; then
7258         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DIRNAME from the environment. Use command line variables instead." >&5
7259 $as_echo "$as_me: WARNING: Ignoring value of DIRNAME from the environment. Use command line variables instead." >&2;}
7260       fi
7261       # Try to locate tool using the code snippet
7262       for ac_prog in dirname
7263 do
7264   # Extract the first word of "$ac_prog", so it can be a program name with args.
7265 set dummy $ac_prog; ac_word=$2
7266 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7267 $as_echo_n "checking for $ac_word... " >&6; }
7268 if ${ac_cv_path_DIRNAME+:} false; then :
7269   $as_echo_n "(cached) " >&6
7270 else
7271   case $DIRNAME in
7272   [\\/]* | ?:[\\/]*)
7273   ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
7274   ;;
7275   *)
7276   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7277 for as_dir in $PATH
7278 do
7279   IFS=$as_save_IFS
7280   test -z "$as_dir" && as_dir=.
7281     for ac_exec_ext in '' $ac_executable_extensions; do
7282   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7283     ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
7284     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7285     break 2
7286   fi
7287 done
7288   done
7289 IFS=$as_save_IFS
7290 
7291   ;;
7292 esac
7293 fi
7294 DIRNAME=$ac_cv_path_DIRNAME
7295 if test -n "$DIRNAME"; then
7296   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
7297 $as_echo "$DIRNAME" >&6; }
7298 else
7299   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7300 $as_echo "no" >&6; }
7301 fi
7302 
7303 
7304   test -n "$DIRNAME" && break
7305 done
7306 
7307     else
7308       # If it succeeded, then it was overridden by the user. We will use it
7309       # for the tool.
7310 
7311       # First remove it from the list of overridden variables, so we can test
7312       # for unknown variables in the end.
7313       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7314 
7315       # Check if we try to supply an empty value
7316       if test "x$DIRNAME" = x; then
7317         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool DIRNAME= (no value)" >&5
7318 $as_echo "$as_me: Setting user supplied tool DIRNAME= (no value)" >&6;}
7319         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIRNAME" >&5
7320 $as_echo_n "checking for DIRNAME... " >&6; }
7321         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
7322 $as_echo "disabled" >&6; }
7323       else
7324         # Check if the provided tool contains a complete path.
7325         tool_specified="$DIRNAME"
7326         tool_basename="${tool_specified##*/}"
7327         if test "x$tool_basename" = "x$tool_specified"; then
7328           # A command without a complete path is provided, search $PATH.
7329           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DIRNAME=$tool_basename" >&5
7330 $as_echo "$as_me: Will search for user supplied tool DIRNAME=$tool_basename" >&6;}
7331           # Extract the first word of "$tool_basename", so it can be a program name with args.
7332 set dummy $tool_basename; ac_word=$2
7333 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7334 $as_echo_n "checking for $ac_word... " >&6; }
7335 if ${ac_cv_path_DIRNAME+:} false; then :
7336   $as_echo_n "(cached) " >&6
7337 else
7338   case $DIRNAME in
7339   [\\/]* | ?:[\\/]*)
7340   ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
7341   ;;
7342   *)
7343   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7344 for as_dir in $PATH
7345 do
7346   IFS=$as_save_IFS
7347   test -z "$as_dir" && as_dir=.
7348     for ac_exec_ext in '' $ac_executable_extensions; do
7349   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7350     ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
7351     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7352     break 2
7353   fi
7354 done
7355   done
7356 IFS=$as_save_IFS
7357 
7358   ;;
7359 esac
7360 fi
7361 DIRNAME=$ac_cv_path_DIRNAME
7362 if test -n "$DIRNAME"; then
7363   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
7364 $as_echo "$DIRNAME" >&6; }
7365 else
7366   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7367 $as_echo "no" >&6; }
7368 fi
7369 
7370 
7371           if test "x$DIRNAME" = x; then
7372             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7373           fi
7374         else
7375           # Otherwise we believe it is a complete path. Use it as it is.
7376           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DIRNAME=$tool_specified" >&5
7377 $as_echo "$as_me: Will use user supplied tool DIRNAME=$tool_specified" >&6;}
7378           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIRNAME" >&5
7379 $as_echo_n "checking for DIRNAME... " >&6; }
7380           if test ! -x "$tool_specified"; then
7381             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7382 $as_echo "not found" >&6; }
7383             as_fn_error $? "User supplied tool DIRNAME=$tool_specified does not exist or is not executable" "$LINENO" 5
7384           fi
7385           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7386 $as_echo "$tool_specified" >&6; }
7387         fi
7388       fi
7389     fi
7390 
7391   fi
7392 
7393 
7394 
7395   if test "x$DIRNAME" = x; then
7396     as_fn_error $? "Could not find required tool for DIRNAME" "$LINENO" 5
7397   fi
7398 
7399 
7400 
7401 
7402 
7403   # Publish this variable in the help.
7404 
7405 
7406   if [ -z "${ECHO+x}" ]; then
7407     # The variable is not set by user, try to locate tool using the code snippet
7408     for ac_prog in echo
7409 do
7410   # Extract the first word of "$ac_prog", so it can be a program name with args.
7411 set dummy $ac_prog; ac_word=$2
7412 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7413 $as_echo_n "checking for $ac_word... " >&6; }
7414 if ${ac_cv_path_ECHO+:} false; then :
7415   $as_echo_n "(cached) " >&6
7416 else
7417   case $ECHO in
7418   [\\/]* | ?:[\\/]*)
7419   ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
7420   ;;
7421   *)
7422   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7423 for as_dir in $PATH
7424 do
7425   IFS=$as_save_IFS
7426   test -z "$as_dir" && as_dir=.
7427     for ac_exec_ext in '' $ac_executable_extensions; do
7428   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7429     ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
7430     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7431     break 2
7432   fi
7433 done
7434   done
7435 IFS=$as_save_IFS
7436 
7437   ;;
7438 esac
7439 fi
7440 ECHO=$ac_cv_path_ECHO
7441 if test -n "$ECHO"; then
7442   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
7443 $as_echo "$ECHO" >&6; }
7444 else
7445   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7446 $as_echo "no" >&6; }
7447 fi
7448 
7449 
7450   test -n "$ECHO" && break
7451 done
7452 
7453   else
7454     # The variable is set, but is it from the command line or the environment?
7455 
7456     # Try to remove the string !ECHO! from our list.
7457     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!ECHO!/}
7458     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7459       # If it failed, the variable was not from the command line. Ignore it,
7460       # but warn the user (except for BASH, which is always set by the calling BASH).
7461       if test "xECHO" != xBASH; then
7462         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ECHO from the environment. Use command line variables instead." >&5
7463 $as_echo "$as_me: WARNING: Ignoring value of ECHO from the environment. Use command line variables instead." >&2;}
7464       fi
7465       # Try to locate tool using the code snippet
7466       for ac_prog in echo
7467 do
7468   # Extract the first word of "$ac_prog", so it can be a program name with args.
7469 set dummy $ac_prog; ac_word=$2
7470 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7471 $as_echo_n "checking for $ac_word... " >&6; }
7472 if ${ac_cv_path_ECHO+:} false; then :
7473   $as_echo_n "(cached) " >&6
7474 else
7475   case $ECHO in
7476   [\\/]* | ?:[\\/]*)
7477   ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
7478   ;;
7479   *)
7480   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7481 for as_dir in $PATH
7482 do
7483   IFS=$as_save_IFS
7484   test -z "$as_dir" && as_dir=.
7485     for ac_exec_ext in '' $ac_executable_extensions; do
7486   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7487     ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
7488     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7489     break 2
7490   fi
7491 done
7492   done
7493 IFS=$as_save_IFS
7494 
7495   ;;
7496 esac
7497 fi
7498 ECHO=$ac_cv_path_ECHO
7499 if test -n "$ECHO"; then
7500   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
7501 $as_echo "$ECHO" >&6; }
7502 else
7503   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7504 $as_echo "no" >&6; }
7505 fi
7506 
7507 
7508   test -n "$ECHO" && break
7509 done
7510 
7511     else
7512       # If it succeeded, then it was overridden by the user. We will use it
7513       # for the tool.
7514 
7515       # First remove it from the list of overridden variables, so we can test
7516       # for unknown variables in the end.
7517       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7518 
7519       # Check if we try to supply an empty value
7520       if test "x$ECHO" = x; then
7521         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool ECHO= (no value)" >&5
7522 $as_echo "$as_me: Setting user supplied tool ECHO= (no value)" >&6;}
7523         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ECHO" >&5
7524 $as_echo_n "checking for ECHO... " >&6; }
7525         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
7526 $as_echo "disabled" >&6; }
7527       else
7528         # Check if the provided tool contains a complete path.
7529         tool_specified="$ECHO"
7530         tool_basename="${tool_specified##*/}"
7531         if test "x$tool_basename" = "x$tool_specified"; then
7532           # A command without a complete path is provided, search $PATH.
7533           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ECHO=$tool_basename" >&5
7534 $as_echo "$as_me: Will search for user supplied tool ECHO=$tool_basename" >&6;}
7535           # Extract the first word of "$tool_basename", so it can be a program name with args.
7536 set dummy $tool_basename; ac_word=$2
7537 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7538 $as_echo_n "checking for $ac_word... " >&6; }
7539 if ${ac_cv_path_ECHO+:} false; then :
7540   $as_echo_n "(cached) " >&6
7541 else
7542   case $ECHO in
7543   [\\/]* | ?:[\\/]*)
7544   ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
7545   ;;
7546   *)
7547   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7548 for as_dir in $PATH
7549 do
7550   IFS=$as_save_IFS
7551   test -z "$as_dir" && as_dir=.
7552     for ac_exec_ext in '' $ac_executable_extensions; do
7553   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7554     ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
7555     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7556     break 2
7557   fi
7558 done
7559   done
7560 IFS=$as_save_IFS
7561 
7562   ;;
7563 esac
7564 fi
7565 ECHO=$ac_cv_path_ECHO
7566 if test -n "$ECHO"; then
7567   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
7568 $as_echo "$ECHO" >&6; }
7569 else
7570   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7571 $as_echo "no" >&6; }
7572 fi
7573 
7574 
7575           if test "x$ECHO" = x; then
7576             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7577           fi
7578         else
7579           # Otherwise we believe it is a complete path. Use it as it is.
7580           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ECHO=$tool_specified" >&5
7581 $as_echo "$as_me: Will use user supplied tool ECHO=$tool_specified" >&6;}
7582           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ECHO" >&5
7583 $as_echo_n "checking for ECHO... " >&6; }
7584           if test ! -x "$tool_specified"; then
7585             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7586 $as_echo "not found" >&6; }
7587             as_fn_error $? "User supplied tool ECHO=$tool_specified does not exist or is not executable" "$LINENO" 5
7588           fi
7589           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7590 $as_echo "$tool_specified" >&6; }
7591         fi
7592       fi
7593     fi
7594 
7595   fi
7596 
7597 
7598 
7599   if test "x$ECHO" = x; then
7600     as_fn_error $? "Could not find required tool for ECHO" "$LINENO" 5
7601   fi
7602 
7603 
7604 
7605 
7606 
7607   # Publish this variable in the help.
7608 
7609 
7610   if [ -z "${EXPR+x}" ]; then
7611     # The variable is not set by user, try to locate tool using the code snippet
7612     for ac_prog in expr
7613 do
7614   # Extract the first word of "$ac_prog", so it can be a program name with args.
7615 set dummy $ac_prog; ac_word=$2
7616 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7617 $as_echo_n "checking for $ac_word... " >&6; }
7618 if ${ac_cv_path_EXPR+:} false; then :
7619   $as_echo_n "(cached) " >&6
7620 else
7621   case $EXPR in
7622   [\\/]* | ?:[\\/]*)
7623   ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
7624   ;;
7625   *)
7626   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7627 for as_dir in $PATH
7628 do
7629   IFS=$as_save_IFS
7630   test -z "$as_dir" && as_dir=.
7631     for ac_exec_ext in '' $ac_executable_extensions; do
7632   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7633     ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
7634     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7635     break 2
7636   fi
7637 done
7638   done
7639 IFS=$as_save_IFS
7640 
7641   ;;
7642 esac
7643 fi
7644 EXPR=$ac_cv_path_EXPR
7645 if test -n "$EXPR"; then
7646   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
7647 $as_echo "$EXPR" >&6; }
7648 else
7649   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7650 $as_echo "no" >&6; }
7651 fi
7652 
7653 
7654   test -n "$EXPR" && break
7655 done
7656 
7657   else
7658     # The variable is set, but is it from the command line or the environment?
7659 
7660     # Try to remove the string !EXPR! from our list.
7661     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!EXPR!/}
7662     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7663       # If it failed, the variable was not from the command line. Ignore it,
7664       # but warn the user (except for BASH, which is always set by the calling BASH).
7665       if test "xEXPR" != xBASH; then
7666         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of EXPR from the environment. Use command line variables instead." >&5
7667 $as_echo "$as_me: WARNING: Ignoring value of EXPR from the environment. Use command line variables instead." >&2;}
7668       fi
7669       # Try to locate tool using the code snippet
7670       for ac_prog in expr
7671 do
7672   # Extract the first word of "$ac_prog", so it can be a program name with args.
7673 set dummy $ac_prog; ac_word=$2
7674 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7675 $as_echo_n "checking for $ac_word... " >&6; }
7676 if ${ac_cv_path_EXPR+:} false; then :
7677   $as_echo_n "(cached) " >&6
7678 else
7679   case $EXPR in
7680   [\\/]* | ?:[\\/]*)
7681   ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
7682   ;;
7683   *)
7684   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7685 for as_dir in $PATH
7686 do
7687   IFS=$as_save_IFS
7688   test -z "$as_dir" && as_dir=.
7689     for ac_exec_ext in '' $ac_executable_extensions; do
7690   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7691     ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
7692     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7693     break 2
7694   fi
7695 done
7696   done
7697 IFS=$as_save_IFS
7698 
7699   ;;
7700 esac
7701 fi
7702 EXPR=$ac_cv_path_EXPR
7703 if test -n "$EXPR"; then
7704   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
7705 $as_echo "$EXPR" >&6; }
7706 else
7707   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7708 $as_echo "no" >&6; }
7709 fi
7710 
7711 
7712   test -n "$EXPR" && break
7713 done
7714 
7715     else
7716       # If it succeeded, then it was overridden by the user. We will use it
7717       # for the tool.
7718 
7719       # First remove it from the list of overridden variables, so we can test
7720       # for unknown variables in the end.
7721       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7722 
7723       # Check if we try to supply an empty value
7724       if test "x$EXPR" = x; then
7725         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool EXPR= (no value)" >&5
7726 $as_echo "$as_me: Setting user supplied tool EXPR= (no value)" >&6;}
7727         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EXPR" >&5
7728 $as_echo_n "checking for EXPR... " >&6; }
7729         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
7730 $as_echo "disabled" >&6; }
7731       else
7732         # Check if the provided tool contains a complete path.
7733         tool_specified="$EXPR"
7734         tool_basename="${tool_specified##*/}"
7735         if test "x$tool_basename" = "x$tool_specified"; then
7736           # A command without a complete path is provided, search $PATH.
7737           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool EXPR=$tool_basename" >&5
7738 $as_echo "$as_me: Will search for user supplied tool EXPR=$tool_basename" >&6;}
7739           # Extract the first word of "$tool_basename", so it can be a program name with args.
7740 set dummy $tool_basename; ac_word=$2
7741 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7742 $as_echo_n "checking for $ac_word... " >&6; }
7743 if ${ac_cv_path_EXPR+:} false; then :
7744   $as_echo_n "(cached) " >&6
7745 else
7746   case $EXPR in
7747   [\\/]* | ?:[\\/]*)
7748   ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
7749   ;;
7750   *)
7751   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7752 for as_dir in $PATH
7753 do
7754   IFS=$as_save_IFS
7755   test -z "$as_dir" && as_dir=.
7756     for ac_exec_ext in '' $ac_executable_extensions; do
7757   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7758     ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
7759     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7760     break 2
7761   fi
7762 done
7763   done
7764 IFS=$as_save_IFS
7765 
7766   ;;
7767 esac
7768 fi
7769 EXPR=$ac_cv_path_EXPR
7770 if test -n "$EXPR"; then
7771   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
7772 $as_echo "$EXPR" >&6; }
7773 else
7774   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7775 $as_echo "no" >&6; }
7776 fi
7777 
7778 
7779           if test "x$EXPR" = x; then
7780             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7781           fi
7782         else
7783           # Otherwise we believe it is a complete path. Use it as it is.
7784           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool EXPR=$tool_specified" >&5
7785 $as_echo "$as_me: Will use user supplied tool EXPR=$tool_specified" >&6;}
7786           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EXPR" >&5
7787 $as_echo_n "checking for EXPR... " >&6; }
7788           if test ! -x "$tool_specified"; then
7789             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7790 $as_echo "not found" >&6; }
7791             as_fn_error $? "User supplied tool EXPR=$tool_specified does not exist or is not executable" "$LINENO" 5
7792           fi
7793           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7794 $as_echo "$tool_specified" >&6; }
7795         fi
7796       fi
7797     fi
7798 
7799   fi
7800 
7801 
7802 
7803   if test "x$EXPR" = x; then
7804     as_fn_error $? "Could not find required tool for EXPR" "$LINENO" 5
7805   fi
7806 
7807 
7808 
7809 
7810 
7811   # Publish this variable in the help.
7812 
7813 
7814   if [ -z "${FILE+x}" ]; then
7815     # The variable is not set by user, try to locate tool using the code snippet
7816     for ac_prog in file
7817 do
7818   # Extract the first word of "$ac_prog", so it can be a program name with args.
7819 set dummy $ac_prog; ac_word=$2
7820 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7821 $as_echo_n "checking for $ac_word... " >&6; }
7822 if ${ac_cv_path_FILE+:} false; then :
7823   $as_echo_n "(cached) " >&6
7824 else
7825   case $FILE in
7826   [\\/]* | ?:[\\/]*)
7827   ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
7828   ;;
7829   *)
7830   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7831 for as_dir in $PATH
7832 do
7833   IFS=$as_save_IFS
7834   test -z "$as_dir" && as_dir=.
7835     for ac_exec_ext in '' $ac_executable_extensions; do
7836   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7837     ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
7838     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7839     break 2
7840   fi
7841 done
7842   done
7843 IFS=$as_save_IFS
7844 
7845   ;;
7846 esac
7847 fi
7848 FILE=$ac_cv_path_FILE
7849 if test -n "$FILE"; then
7850   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
7851 $as_echo "$FILE" >&6; }
7852 else
7853   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7854 $as_echo "no" >&6; }
7855 fi
7856 
7857 
7858   test -n "$FILE" && break
7859 done
7860 
7861   else
7862     # The variable is set, but is it from the command line or the environment?
7863 
7864     # Try to remove the string !FILE! from our list.
7865     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FILE!/}
7866     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7867       # If it failed, the variable was not from the command line. Ignore it,
7868       # but warn the user (except for BASH, which is always set by the calling BASH).
7869       if test "xFILE" != xBASH; then
7870         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FILE from the environment. Use command line variables instead." >&5
7871 $as_echo "$as_me: WARNING: Ignoring value of FILE from the environment. Use command line variables instead." >&2;}
7872       fi
7873       # Try to locate tool using the code snippet
7874       for ac_prog in file
7875 do
7876   # Extract the first word of "$ac_prog", so it can be a program name with args.
7877 set dummy $ac_prog; ac_word=$2
7878 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7879 $as_echo_n "checking for $ac_word... " >&6; }
7880 if ${ac_cv_path_FILE+:} false; then :
7881   $as_echo_n "(cached) " >&6
7882 else
7883   case $FILE in
7884   [\\/]* | ?:[\\/]*)
7885   ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
7886   ;;
7887   *)
7888   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7889 for as_dir in $PATH
7890 do
7891   IFS=$as_save_IFS
7892   test -z "$as_dir" && as_dir=.
7893     for ac_exec_ext in '' $ac_executable_extensions; do
7894   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7895     ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
7896     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7897     break 2
7898   fi
7899 done
7900   done
7901 IFS=$as_save_IFS
7902 
7903   ;;
7904 esac
7905 fi
7906 FILE=$ac_cv_path_FILE
7907 if test -n "$FILE"; then
7908   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
7909 $as_echo "$FILE" >&6; }
7910 else
7911   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7912 $as_echo "no" >&6; }
7913 fi
7914 
7915 
7916   test -n "$FILE" && break
7917 done
7918 
7919     else
7920       # If it succeeded, then it was overridden by the user. We will use it
7921       # for the tool.
7922 
7923       # First remove it from the list of overridden variables, so we can test
7924       # for unknown variables in the end.
7925       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7926 
7927       # Check if we try to supply an empty value
7928       if test "x$FILE" = x; then
7929         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool FILE= (no value)" >&5
7930 $as_echo "$as_me: Setting user supplied tool FILE= (no value)" >&6;}
7931         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FILE" >&5
7932 $as_echo_n "checking for FILE... " >&6; }
7933         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
7934 $as_echo "disabled" >&6; }
7935       else
7936         # Check if the provided tool contains a complete path.
7937         tool_specified="$FILE"
7938         tool_basename="${tool_specified##*/}"
7939         if test "x$tool_basename" = "x$tool_specified"; then
7940           # A command without a complete path is provided, search $PATH.
7941           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FILE=$tool_basename" >&5
7942 $as_echo "$as_me: Will search for user supplied tool FILE=$tool_basename" >&6;}
7943           # Extract the first word of "$tool_basename", so it can be a program name with args.
7944 set dummy $tool_basename; ac_word=$2
7945 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7946 $as_echo_n "checking for $ac_word... " >&6; }
7947 if ${ac_cv_path_FILE+:} false; then :
7948   $as_echo_n "(cached) " >&6
7949 else
7950   case $FILE in
7951   [\\/]* | ?:[\\/]*)
7952   ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
7953   ;;
7954   *)
7955   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7956 for as_dir in $PATH
7957 do
7958   IFS=$as_save_IFS
7959   test -z "$as_dir" && as_dir=.
7960     for ac_exec_ext in '' $ac_executable_extensions; do
7961   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7962     ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
7963     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7964     break 2
7965   fi
7966 done
7967   done
7968 IFS=$as_save_IFS
7969 
7970   ;;
7971 esac
7972 fi
7973 FILE=$ac_cv_path_FILE
7974 if test -n "$FILE"; then
7975   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
7976 $as_echo "$FILE" >&6; }
7977 else
7978   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7979 $as_echo "no" >&6; }
7980 fi
7981 
7982 
7983           if test "x$FILE" = x; then
7984             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7985           fi
7986         else
7987           # Otherwise we believe it is a complete path. Use it as it is.
7988           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FILE=$tool_specified" >&5
7989 $as_echo "$as_me: Will use user supplied tool FILE=$tool_specified" >&6;}
7990           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FILE" >&5
7991 $as_echo_n "checking for FILE... " >&6; }
7992           if test ! -x "$tool_specified"; then
7993             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7994 $as_echo "not found" >&6; }
7995             as_fn_error $? "User supplied tool FILE=$tool_specified does not exist or is not executable" "$LINENO" 5
7996           fi
7997           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7998 $as_echo "$tool_specified" >&6; }
7999         fi
8000       fi
8001     fi
8002 
8003   fi
8004 
8005 
8006 
8007   if test "x$FILE" = x; then
8008     as_fn_error $? "Could not find required tool for FILE" "$LINENO" 5
8009   fi
8010 
8011 
8012 
8013 
8014 
8015   # Publish this variable in the help.
8016 
8017 
8018   if [ -z "${FIND+x}" ]; then
8019     # The variable is not set by user, try to locate tool using the code snippet
8020     for ac_prog in find
8021 do
8022   # Extract the first word of "$ac_prog", so it can be a program name with args.
8023 set dummy $ac_prog; ac_word=$2
8024 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8025 $as_echo_n "checking for $ac_word... " >&6; }
8026 if ${ac_cv_path_FIND+:} false; then :
8027   $as_echo_n "(cached) " >&6
8028 else
8029   case $FIND in
8030   [\\/]* | ?:[\\/]*)
8031   ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
8032   ;;
8033   *)
8034   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8035 for as_dir in $PATH
8036 do
8037   IFS=$as_save_IFS
8038   test -z "$as_dir" && as_dir=.
8039     for ac_exec_ext in '' $ac_executable_extensions; do
8040   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8041     ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
8042     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8043     break 2
8044   fi
8045 done
8046   done
8047 IFS=$as_save_IFS
8048 
8049   ;;
8050 esac
8051 fi
8052 FIND=$ac_cv_path_FIND
8053 if test -n "$FIND"; then
8054   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
8055 $as_echo "$FIND" >&6; }
8056 else
8057   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8058 $as_echo "no" >&6; }
8059 fi
8060 
8061 
8062   test -n "$FIND" && break
8063 done
8064 
8065   else
8066     # The variable is set, but is it from the command line or the environment?
8067 
8068     # Try to remove the string !FIND! from our list.
8069     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FIND!/}
8070     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8071       # If it failed, the variable was not from the command line. Ignore it,
8072       # but warn the user (except for BASH, which is always set by the calling BASH).
8073       if test "xFIND" != xBASH; then
8074         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FIND from the environment. Use command line variables instead." >&5
8075 $as_echo "$as_me: WARNING: Ignoring value of FIND from the environment. Use command line variables instead." >&2;}
8076       fi
8077       # Try to locate tool using the code snippet
8078       for ac_prog in find
8079 do
8080   # Extract the first word of "$ac_prog", so it can be a program name with args.
8081 set dummy $ac_prog; ac_word=$2
8082 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8083 $as_echo_n "checking for $ac_word... " >&6; }
8084 if ${ac_cv_path_FIND+:} false; then :
8085   $as_echo_n "(cached) " >&6
8086 else
8087   case $FIND in
8088   [\\/]* | ?:[\\/]*)
8089   ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
8090   ;;
8091   *)
8092   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8093 for as_dir in $PATH
8094 do
8095   IFS=$as_save_IFS
8096   test -z "$as_dir" && as_dir=.
8097     for ac_exec_ext in '' $ac_executable_extensions; do
8098   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8099     ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
8100     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8101     break 2
8102   fi
8103 done
8104   done
8105 IFS=$as_save_IFS
8106 
8107   ;;
8108 esac
8109 fi
8110 FIND=$ac_cv_path_FIND
8111 if test -n "$FIND"; then
8112   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
8113 $as_echo "$FIND" >&6; }
8114 else
8115   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8116 $as_echo "no" >&6; }
8117 fi
8118 
8119 
8120   test -n "$FIND" && break
8121 done
8122 
8123     else
8124       # If it succeeded, then it was overridden by the user. We will use it
8125       # for the tool.
8126 
8127       # First remove it from the list of overridden variables, so we can test
8128       # for unknown variables in the end.
8129       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8130 
8131       # Check if we try to supply an empty value
8132       if test "x$FIND" = x; then
8133         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool FIND= (no value)" >&5
8134 $as_echo "$as_me: Setting user supplied tool FIND= (no value)" >&6;}
8135         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FIND" >&5
8136 $as_echo_n "checking for FIND... " >&6; }
8137         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
8138 $as_echo "disabled" >&6; }
8139       else
8140         # Check if the provided tool contains a complete path.
8141         tool_specified="$FIND"
8142         tool_basename="${tool_specified##*/}"
8143         if test "x$tool_basename" = "x$tool_specified"; then
8144           # A command without a complete path is provided, search $PATH.
8145           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FIND=$tool_basename" >&5
8146 $as_echo "$as_me: Will search for user supplied tool FIND=$tool_basename" >&6;}
8147           # Extract the first word of "$tool_basename", so it can be a program name with args.
8148 set dummy $tool_basename; ac_word=$2
8149 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8150 $as_echo_n "checking for $ac_word... " >&6; }
8151 if ${ac_cv_path_FIND+:} false; then :
8152   $as_echo_n "(cached) " >&6
8153 else
8154   case $FIND in
8155   [\\/]* | ?:[\\/]*)
8156   ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
8157   ;;
8158   *)
8159   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8160 for as_dir in $PATH
8161 do
8162   IFS=$as_save_IFS
8163   test -z "$as_dir" && as_dir=.
8164     for ac_exec_ext in '' $ac_executable_extensions; do
8165   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8166     ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
8167     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8168     break 2
8169   fi
8170 done
8171   done
8172 IFS=$as_save_IFS
8173 
8174   ;;
8175 esac
8176 fi
8177 FIND=$ac_cv_path_FIND
8178 if test -n "$FIND"; then
8179   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
8180 $as_echo "$FIND" >&6; }
8181 else
8182   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8183 $as_echo "no" >&6; }
8184 fi
8185 
8186 
8187           if test "x$FIND" = x; then
8188             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8189           fi
8190         else
8191           # Otherwise we believe it is a complete path. Use it as it is.
8192           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FIND=$tool_specified" >&5
8193 $as_echo "$as_me: Will use user supplied tool FIND=$tool_specified" >&6;}
8194           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FIND" >&5
8195 $as_echo_n "checking for FIND... " >&6; }
8196           if test ! -x "$tool_specified"; then
8197             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8198 $as_echo "not found" >&6; }
8199             as_fn_error $? "User supplied tool FIND=$tool_specified does not exist or is not executable" "$LINENO" 5
8200           fi
8201           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8202 $as_echo "$tool_specified" >&6; }
8203         fi
8204       fi
8205     fi
8206 
8207   fi
8208 
8209 
8210 
8211   if test "x$FIND" = x; then
8212     as_fn_error $? "Could not find required tool for FIND" "$LINENO" 5
8213   fi
8214 
8215 
8216 
8217 
8218 
8219   # Publish this variable in the help.
8220 
8221 
8222   if [ -z "${HEAD+x}" ]; then
8223     # The variable is not set by user, try to locate tool using the code snippet
8224     for ac_prog in head
8225 do
8226   # Extract the first word of "$ac_prog", so it can be a program name with args.
8227 set dummy $ac_prog; ac_word=$2
8228 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8229 $as_echo_n "checking for $ac_word... " >&6; }
8230 if ${ac_cv_path_HEAD+:} false; then :
8231   $as_echo_n "(cached) " >&6
8232 else
8233   case $HEAD in
8234   [\\/]* | ?:[\\/]*)
8235   ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
8236   ;;
8237   *)
8238   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8239 for as_dir in $PATH
8240 do
8241   IFS=$as_save_IFS
8242   test -z "$as_dir" && as_dir=.
8243     for ac_exec_ext in '' $ac_executable_extensions; do
8244   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8245     ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
8246     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8247     break 2
8248   fi
8249 done
8250   done
8251 IFS=$as_save_IFS
8252 
8253   ;;
8254 esac
8255 fi
8256 HEAD=$ac_cv_path_HEAD
8257 if test -n "$HEAD"; then
8258   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
8259 $as_echo "$HEAD" >&6; }
8260 else
8261   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8262 $as_echo "no" >&6; }
8263 fi
8264 
8265 
8266   test -n "$HEAD" && break
8267 done
8268 
8269   else
8270     # The variable is set, but is it from the command line or the environment?
8271 
8272     # Try to remove the string !HEAD! from our list.
8273     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!HEAD!/}
8274     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8275       # If it failed, the variable was not from the command line. Ignore it,
8276       # but warn the user (except for BASH, which is always set by the calling BASH).
8277       if test "xHEAD" != xBASH; then
8278         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of HEAD from the environment. Use command line variables instead." >&5
8279 $as_echo "$as_me: WARNING: Ignoring value of HEAD from the environment. Use command line variables instead." >&2;}
8280       fi
8281       # Try to locate tool using the code snippet
8282       for ac_prog in head
8283 do
8284   # Extract the first word of "$ac_prog", so it can be a program name with args.
8285 set dummy $ac_prog; ac_word=$2
8286 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8287 $as_echo_n "checking for $ac_word... " >&6; }
8288 if ${ac_cv_path_HEAD+:} false; then :
8289   $as_echo_n "(cached) " >&6
8290 else
8291   case $HEAD in
8292   [\\/]* | ?:[\\/]*)
8293   ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
8294   ;;
8295   *)
8296   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8297 for as_dir in $PATH
8298 do
8299   IFS=$as_save_IFS
8300   test -z "$as_dir" && as_dir=.
8301     for ac_exec_ext in '' $ac_executable_extensions; do
8302   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8303     ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
8304     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8305     break 2
8306   fi
8307 done
8308   done
8309 IFS=$as_save_IFS
8310 
8311   ;;
8312 esac
8313 fi
8314 HEAD=$ac_cv_path_HEAD
8315 if test -n "$HEAD"; then
8316   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
8317 $as_echo "$HEAD" >&6; }
8318 else
8319   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8320 $as_echo "no" >&6; }
8321 fi
8322 
8323 
8324   test -n "$HEAD" && break
8325 done
8326 
8327     else
8328       # If it succeeded, then it was overridden by the user. We will use it
8329       # for the tool.
8330 
8331       # First remove it from the list of overridden variables, so we can test
8332       # for unknown variables in the end.
8333       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8334 
8335       # Check if we try to supply an empty value
8336       if test "x$HEAD" = x; then
8337         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool HEAD= (no value)" >&5
8338 $as_echo "$as_me: Setting user supplied tool HEAD= (no value)" >&6;}
8339         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HEAD" >&5
8340 $as_echo_n "checking for HEAD... " >&6; }
8341         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
8342 $as_echo "disabled" >&6; }
8343       else
8344         # Check if the provided tool contains a complete path.
8345         tool_specified="$HEAD"
8346         tool_basename="${tool_specified##*/}"
8347         if test "x$tool_basename" = "x$tool_specified"; then
8348           # A command without a complete path is provided, search $PATH.
8349           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool HEAD=$tool_basename" >&5
8350 $as_echo "$as_me: Will search for user supplied tool HEAD=$tool_basename" >&6;}
8351           # Extract the first word of "$tool_basename", so it can be a program name with args.
8352 set dummy $tool_basename; ac_word=$2
8353 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8354 $as_echo_n "checking for $ac_word... " >&6; }
8355 if ${ac_cv_path_HEAD+:} false; then :
8356   $as_echo_n "(cached) " >&6
8357 else
8358   case $HEAD in
8359   [\\/]* | ?:[\\/]*)
8360   ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
8361   ;;
8362   *)
8363   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8364 for as_dir in $PATH
8365 do
8366   IFS=$as_save_IFS
8367   test -z "$as_dir" && as_dir=.
8368     for ac_exec_ext in '' $ac_executable_extensions; do
8369   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8370     ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
8371     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8372     break 2
8373   fi
8374 done
8375   done
8376 IFS=$as_save_IFS
8377 
8378   ;;
8379 esac
8380 fi
8381 HEAD=$ac_cv_path_HEAD
8382 if test -n "$HEAD"; then
8383   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
8384 $as_echo "$HEAD" >&6; }
8385 else
8386   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8387 $as_echo "no" >&6; }
8388 fi
8389 
8390 
8391           if test "x$HEAD" = x; then
8392             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8393           fi
8394         else
8395           # Otherwise we believe it is a complete path. Use it as it is.
8396           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool HEAD=$tool_specified" >&5
8397 $as_echo "$as_me: Will use user supplied tool HEAD=$tool_specified" >&6;}
8398           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HEAD" >&5
8399 $as_echo_n "checking for HEAD... " >&6; }
8400           if test ! -x "$tool_specified"; then
8401             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8402 $as_echo "not found" >&6; }
8403             as_fn_error $? "User supplied tool HEAD=$tool_specified does not exist or is not executable" "$LINENO" 5
8404           fi
8405           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8406 $as_echo "$tool_specified" >&6; }
8407         fi
8408       fi
8409     fi
8410 
8411   fi
8412 
8413 
8414 
8415   if test "x$HEAD" = x; then
8416     as_fn_error $? "Could not find required tool for HEAD" "$LINENO" 5
8417   fi
8418 
8419 
8420 
8421 
8422 
8423   # Publish this variable in the help.
8424 
8425 
8426   if [ -z "${GUNZIP+x}" ]; then
8427     # The variable is not set by user, try to locate tool using the code snippet
8428     for ac_prog in gunzip
8429 do
8430   # Extract the first word of "$ac_prog", so it can be a program name with args.
8431 set dummy $ac_prog; ac_word=$2
8432 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8433 $as_echo_n "checking for $ac_word... " >&6; }
8434 if ${ac_cv_path_GUNZIP+:} false; then :
8435   $as_echo_n "(cached) " >&6
8436 else
8437   case $GUNZIP in
8438   [\\/]* | ?:[\\/]*)
8439   ac_cv_path_GUNZIP="$GUNZIP" # Let the user override the test with a path.
8440   ;;
8441   *)
8442   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8443 for as_dir in $PATH
8444 do
8445   IFS=$as_save_IFS
8446   test -z "$as_dir" && as_dir=.
8447     for ac_exec_ext in '' $ac_executable_extensions; do
8448   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8449     ac_cv_path_GUNZIP="$as_dir/$ac_word$ac_exec_ext"
8450     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8451     break 2
8452   fi
8453 done
8454   done
8455 IFS=$as_save_IFS
8456 
8457   ;;
8458 esac
8459 fi
8460 GUNZIP=$ac_cv_path_GUNZIP
8461 if test -n "$GUNZIP"; then
8462   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GUNZIP" >&5
8463 $as_echo "$GUNZIP" >&6; }
8464 else
8465   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8466 $as_echo "no" >&6; }
8467 fi
8468 
8469 
8470   test -n "$GUNZIP" && break
8471 done
8472 
8473   else
8474     # The variable is set, but is it from the command line or the environment?
8475 
8476     # Try to remove the string !GUNZIP! from our list.
8477     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!GUNZIP!/}
8478     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8479       # If it failed, the variable was not from the command line. Ignore it,
8480       # but warn the user (except for BASH, which is always set by the calling BASH).
8481       if test "xGUNZIP" != xBASH; then
8482         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of GUNZIP from the environment. Use command line variables instead." >&5
8483 $as_echo "$as_me: WARNING: Ignoring value of GUNZIP from the environment. Use command line variables instead." >&2;}
8484       fi
8485       # Try to locate tool using the code snippet
8486       for ac_prog in gunzip
8487 do
8488   # Extract the first word of "$ac_prog", so it can be a program name with args.
8489 set dummy $ac_prog; ac_word=$2
8490 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8491 $as_echo_n "checking for $ac_word... " >&6; }
8492 if ${ac_cv_path_GUNZIP+:} false; then :
8493   $as_echo_n "(cached) " >&6
8494 else
8495   case $GUNZIP in
8496   [\\/]* | ?:[\\/]*)
8497   ac_cv_path_GUNZIP="$GUNZIP" # Let the user override the test with a path.
8498   ;;
8499   *)
8500   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8501 for as_dir in $PATH
8502 do
8503   IFS=$as_save_IFS
8504   test -z "$as_dir" && as_dir=.
8505     for ac_exec_ext in '' $ac_executable_extensions; do
8506   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8507     ac_cv_path_GUNZIP="$as_dir/$ac_word$ac_exec_ext"
8508     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8509     break 2
8510   fi
8511 done
8512   done
8513 IFS=$as_save_IFS
8514 
8515   ;;
8516 esac
8517 fi
8518 GUNZIP=$ac_cv_path_GUNZIP
8519 if test -n "$GUNZIP"; then
8520   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GUNZIP" >&5
8521 $as_echo "$GUNZIP" >&6; }
8522 else
8523   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8524 $as_echo "no" >&6; }
8525 fi
8526 
8527 
8528   test -n "$GUNZIP" && break
8529 done
8530 
8531     else
8532       # If it succeeded, then it was overridden by the user. We will use it
8533       # for the tool.
8534 
8535       # First remove it from the list of overridden variables, so we can test
8536       # for unknown variables in the end.
8537       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8538 
8539       # Check if we try to supply an empty value
8540       if test "x$GUNZIP" = x; then
8541         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool GUNZIP= (no value)" >&5
8542 $as_echo "$as_me: Setting user supplied tool GUNZIP= (no value)" >&6;}
8543         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GUNZIP" >&5
8544 $as_echo_n "checking for GUNZIP... " >&6; }
8545         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
8546 $as_echo "disabled" >&6; }
8547       else
8548         # Check if the provided tool contains a complete path.
8549         tool_specified="$GUNZIP"
8550         tool_basename="${tool_specified##*/}"
8551         if test "x$tool_basename" = "x$tool_specified"; then
8552           # A command without a complete path is provided, search $PATH.
8553           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool GUNZIP=$tool_basename" >&5
8554 $as_echo "$as_me: Will search for user supplied tool GUNZIP=$tool_basename" >&6;}
8555           # Extract the first word of "$tool_basename", so it can be a program name with args.
8556 set dummy $tool_basename; ac_word=$2
8557 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8558 $as_echo_n "checking for $ac_word... " >&6; }
8559 if ${ac_cv_path_GUNZIP+:} false; then :
8560   $as_echo_n "(cached) " >&6
8561 else
8562   case $GUNZIP in
8563   [\\/]* | ?:[\\/]*)
8564   ac_cv_path_GUNZIP="$GUNZIP" # Let the user override the test with a path.
8565   ;;
8566   *)
8567   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8568 for as_dir in $PATH
8569 do
8570   IFS=$as_save_IFS
8571   test -z "$as_dir" && as_dir=.
8572     for ac_exec_ext in '' $ac_executable_extensions; do
8573   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8574     ac_cv_path_GUNZIP="$as_dir/$ac_word$ac_exec_ext"
8575     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8576     break 2
8577   fi
8578 done
8579   done
8580 IFS=$as_save_IFS
8581 
8582   ;;
8583 esac
8584 fi
8585 GUNZIP=$ac_cv_path_GUNZIP
8586 if test -n "$GUNZIP"; then
8587   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GUNZIP" >&5
8588 $as_echo "$GUNZIP" >&6; }
8589 else
8590   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8591 $as_echo "no" >&6; }
8592 fi
8593 
8594 
8595           if test "x$GUNZIP" = x; then
8596             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8597           fi
8598         else
8599           # Otherwise we believe it is a complete path. Use it as it is.
8600           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool GUNZIP=$tool_specified" >&5
8601 $as_echo "$as_me: Will use user supplied tool GUNZIP=$tool_specified" >&6;}
8602           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GUNZIP" >&5
8603 $as_echo_n "checking for GUNZIP... " >&6; }
8604           if test ! -x "$tool_specified"; then
8605             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8606 $as_echo "not found" >&6; }
8607             as_fn_error $? "User supplied tool GUNZIP=$tool_specified does not exist or is not executable" "$LINENO" 5
8608           fi
8609           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8610 $as_echo "$tool_specified" >&6; }
8611         fi
8612       fi
8613     fi
8614 
8615   fi
8616 
8617 
8618 
8619   if test "x$GUNZIP" = x; then
8620     as_fn_error $? "Could not find required tool for GUNZIP" "$LINENO" 5
8621   fi
8622 
8623 
8624 
8625 
8626 
8627   # Publish this variable in the help.
8628 
8629 
8630   if [ -z "${GZIP+x}" ]; then
8631     # The variable is not set by user, try to locate tool using the code snippet
8632     for ac_prog in pigz gzip
8633 do
8634   # Extract the first word of "$ac_prog", so it can be a program name with args.
8635 set dummy $ac_prog; ac_word=$2
8636 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8637 $as_echo_n "checking for $ac_word... " >&6; }
8638 if ${ac_cv_path_GZIP+:} false; then :
8639   $as_echo_n "(cached) " >&6
8640 else
8641   case $GZIP in
8642   [\\/]* | ?:[\\/]*)
8643   ac_cv_path_GZIP="$GZIP" # Let the user override the test with a path.
8644   ;;
8645   *)
8646   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8647 for as_dir in $PATH
8648 do
8649   IFS=$as_save_IFS
8650   test -z "$as_dir" && as_dir=.
8651     for ac_exec_ext in '' $ac_executable_extensions; do
8652   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8653     ac_cv_path_GZIP="$as_dir/$ac_word$ac_exec_ext"
8654     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8655     break 2
8656   fi
8657 done
8658   done
8659 IFS=$as_save_IFS
8660 
8661   ;;
8662 esac
8663 fi
8664 GZIP=$ac_cv_path_GZIP
8665 if test -n "$GZIP"; then
8666   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GZIP" >&5
8667 $as_echo "$GZIP" >&6; }
8668 else
8669   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8670 $as_echo "no" >&6; }
8671 fi
8672 
8673 
8674   test -n "$GZIP" && break
8675 done
8676 
8677   else
8678     # The variable is set, but is it from the command line or the environment?
8679 
8680     # Try to remove the string !GZIP! from our list.
8681     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!GZIP!/}
8682     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8683       # If it failed, the variable was not from the command line. Ignore it,
8684       # but warn the user (except for BASH, which is always set by the calling BASH).
8685       if test "xGZIP" != xBASH; then
8686         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of GZIP from the environment. Use command line variables instead." >&5
8687 $as_echo "$as_me: WARNING: Ignoring value of GZIP from the environment. Use command line variables instead." >&2;}
8688       fi
8689       # Try to locate tool using the code snippet
8690       for ac_prog in pigz gzip
8691 do
8692   # Extract the first word of "$ac_prog", so it can be a program name with args.
8693 set dummy $ac_prog; ac_word=$2
8694 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8695 $as_echo_n "checking for $ac_word... " >&6; }
8696 if ${ac_cv_path_GZIP+:} false; then :
8697   $as_echo_n "(cached) " >&6
8698 else
8699   case $GZIP in
8700   [\\/]* | ?:[\\/]*)
8701   ac_cv_path_GZIP="$GZIP" # Let the user override the test with a path.
8702   ;;
8703   *)
8704   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8705 for as_dir in $PATH
8706 do
8707   IFS=$as_save_IFS
8708   test -z "$as_dir" && as_dir=.
8709     for ac_exec_ext in '' $ac_executable_extensions; do
8710   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8711     ac_cv_path_GZIP="$as_dir/$ac_word$ac_exec_ext"
8712     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8713     break 2
8714   fi
8715 done
8716   done
8717 IFS=$as_save_IFS
8718 
8719   ;;
8720 esac
8721 fi
8722 GZIP=$ac_cv_path_GZIP
8723 if test -n "$GZIP"; then
8724   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GZIP" >&5
8725 $as_echo "$GZIP" >&6; }
8726 else
8727   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8728 $as_echo "no" >&6; }
8729 fi
8730 
8731 
8732   test -n "$GZIP" && break
8733 done
8734 
8735     else
8736       # If it succeeded, then it was overridden by the user. We will use it
8737       # for the tool.
8738 
8739       # First remove it from the list of overridden variables, so we can test
8740       # for unknown variables in the end.
8741       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8742 
8743       # Check if we try to supply an empty value
8744       if test "x$GZIP" = x; then
8745         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool GZIP= (no value)" >&5
8746 $as_echo "$as_me: Setting user supplied tool GZIP= (no value)" >&6;}
8747         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GZIP" >&5
8748 $as_echo_n "checking for GZIP... " >&6; }
8749         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
8750 $as_echo "disabled" >&6; }
8751       else
8752         # Check if the provided tool contains a complete path.
8753         tool_specified="$GZIP"
8754         tool_basename="${tool_specified##*/}"
8755         if test "x$tool_basename" = "x$tool_specified"; then
8756           # A command without a complete path is provided, search $PATH.
8757           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool GZIP=$tool_basename" >&5
8758 $as_echo "$as_me: Will search for user supplied tool GZIP=$tool_basename" >&6;}
8759           # Extract the first word of "$tool_basename", so it can be a program name with args.
8760 set dummy $tool_basename; ac_word=$2
8761 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8762 $as_echo_n "checking for $ac_word... " >&6; }
8763 if ${ac_cv_path_GZIP+:} false; then :
8764   $as_echo_n "(cached) " >&6
8765 else
8766   case $GZIP in
8767   [\\/]* | ?:[\\/]*)
8768   ac_cv_path_GZIP="$GZIP" # Let the user override the test with a path.
8769   ;;
8770   *)
8771   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8772 for as_dir in $PATH
8773 do
8774   IFS=$as_save_IFS
8775   test -z "$as_dir" && as_dir=.
8776     for ac_exec_ext in '' $ac_executable_extensions; do
8777   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8778     ac_cv_path_GZIP="$as_dir/$ac_word$ac_exec_ext"
8779     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8780     break 2
8781   fi
8782 done
8783   done
8784 IFS=$as_save_IFS
8785 
8786   ;;
8787 esac
8788 fi
8789 GZIP=$ac_cv_path_GZIP
8790 if test -n "$GZIP"; then
8791   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GZIP" >&5
8792 $as_echo "$GZIP" >&6; }
8793 else
8794   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8795 $as_echo "no" >&6; }
8796 fi
8797 
8798 
8799           if test "x$GZIP" = x; then
8800             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8801           fi
8802         else
8803           # Otherwise we believe it is a complete path. Use it as it is.
8804           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool GZIP=$tool_specified" >&5
8805 $as_echo "$as_me: Will use user supplied tool GZIP=$tool_specified" >&6;}
8806           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GZIP" >&5
8807 $as_echo_n "checking for GZIP... " >&6; }
8808           if test ! -x "$tool_specified"; then
8809             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8810 $as_echo "not found" >&6; }
8811             as_fn_error $? "User supplied tool GZIP=$tool_specified does not exist or is not executable" "$LINENO" 5
8812           fi
8813           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8814 $as_echo "$tool_specified" >&6; }
8815         fi
8816       fi
8817     fi
8818 
8819   fi
8820 
8821 
8822 
8823   if test "x$GZIP" = x; then
8824     as_fn_error $? "Could not find required tool for GZIP" "$LINENO" 5
8825   fi
8826 
8827 
8828 
8829 
8830 
8831   # Publish this variable in the help.
8832 
8833 
8834   if [ -z "${LN+x}" ]; then
8835     # The variable is not set by user, try to locate tool using the code snippet
8836     for ac_prog in ln
8837 do
8838   # Extract the first word of "$ac_prog", so it can be a program name with args.
8839 set dummy $ac_prog; ac_word=$2
8840 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8841 $as_echo_n "checking for $ac_word... " >&6; }
8842 if ${ac_cv_path_LN+:} false; then :
8843   $as_echo_n "(cached) " >&6
8844 else
8845   case $LN in
8846   [\\/]* | ?:[\\/]*)
8847   ac_cv_path_LN="$LN" # Let the user override the test with a path.
8848   ;;
8849   *)
8850   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8851 for as_dir in $PATH
8852 do
8853   IFS=$as_save_IFS
8854   test -z "$as_dir" && as_dir=.
8855     for ac_exec_ext in '' $ac_executable_extensions; do
8856   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8857     ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
8858     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8859     break 2
8860   fi
8861 done
8862   done
8863 IFS=$as_save_IFS
8864 
8865   ;;
8866 esac
8867 fi
8868 LN=$ac_cv_path_LN
8869 if test -n "$LN"; then
8870   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
8871 $as_echo "$LN" >&6; }
8872 else
8873   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8874 $as_echo "no" >&6; }
8875 fi
8876 
8877 
8878   test -n "$LN" && break
8879 done
8880 
8881   else
8882     # The variable is set, but is it from the command line or the environment?
8883 
8884     # Try to remove the string !LN! from our list.
8885     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LN!/}
8886     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8887       # If it failed, the variable was not from the command line. Ignore it,
8888       # but warn the user (except for BASH, which is always set by the calling BASH).
8889       if test "xLN" != xBASH; then
8890         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LN from the environment. Use command line variables instead." >&5
8891 $as_echo "$as_me: WARNING: Ignoring value of LN from the environment. Use command line variables instead." >&2;}
8892       fi
8893       # Try to locate tool using the code snippet
8894       for ac_prog in ln
8895 do
8896   # Extract the first word of "$ac_prog", so it can be a program name with args.
8897 set dummy $ac_prog; ac_word=$2
8898 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8899 $as_echo_n "checking for $ac_word... " >&6; }
8900 if ${ac_cv_path_LN+:} false; then :
8901   $as_echo_n "(cached) " >&6
8902 else
8903   case $LN in
8904   [\\/]* | ?:[\\/]*)
8905   ac_cv_path_LN="$LN" # Let the user override the test with a path.
8906   ;;
8907   *)
8908   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8909 for as_dir in $PATH
8910 do
8911   IFS=$as_save_IFS
8912   test -z "$as_dir" && as_dir=.
8913     for ac_exec_ext in '' $ac_executable_extensions; do
8914   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8915     ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
8916     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8917     break 2
8918   fi
8919 done
8920   done
8921 IFS=$as_save_IFS
8922 
8923   ;;
8924 esac
8925 fi
8926 LN=$ac_cv_path_LN
8927 if test -n "$LN"; then
8928   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
8929 $as_echo "$LN" >&6; }
8930 else
8931   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8932 $as_echo "no" >&6; }
8933 fi
8934 
8935 
8936   test -n "$LN" && break
8937 done
8938 
8939     else
8940       # If it succeeded, then it was overridden by the user. We will use it
8941       # for the tool.
8942 
8943       # First remove it from the list of overridden variables, so we can test
8944       # for unknown variables in the end.
8945       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8946 
8947       # Check if we try to supply an empty value
8948       if test "x$LN" = x; then
8949         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool LN= (no value)" >&5
8950 $as_echo "$as_me: Setting user supplied tool LN= (no value)" >&6;}
8951         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LN" >&5
8952 $as_echo_n "checking for LN... " >&6; }
8953         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
8954 $as_echo "disabled" >&6; }
8955       else
8956         # Check if the provided tool contains a complete path.
8957         tool_specified="$LN"
8958         tool_basename="${tool_specified##*/}"
8959         if test "x$tool_basename" = "x$tool_specified"; then
8960           # A command without a complete path is provided, search $PATH.
8961           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LN=$tool_basename" >&5
8962 $as_echo "$as_me: Will search for user supplied tool LN=$tool_basename" >&6;}
8963           # Extract the first word of "$tool_basename", so it can be a program name with args.
8964 set dummy $tool_basename; ac_word=$2
8965 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8966 $as_echo_n "checking for $ac_word... " >&6; }
8967 if ${ac_cv_path_LN+:} false; then :
8968   $as_echo_n "(cached) " >&6
8969 else
8970   case $LN in
8971   [\\/]* | ?:[\\/]*)
8972   ac_cv_path_LN="$LN" # Let the user override the test with a path.
8973   ;;
8974   *)
8975   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8976 for as_dir in $PATH
8977 do
8978   IFS=$as_save_IFS
8979   test -z "$as_dir" && as_dir=.
8980     for ac_exec_ext in '' $ac_executable_extensions; do
8981   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8982     ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
8983     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8984     break 2
8985   fi
8986 done
8987   done
8988 IFS=$as_save_IFS
8989 
8990   ;;
8991 esac
8992 fi
8993 LN=$ac_cv_path_LN
8994 if test -n "$LN"; then
8995   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
8996 $as_echo "$LN" >&6; }
8997 else
8998   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8999 $as_echo "no" >&6; }
9000 fi
9001 
9002 
9003           if test "x$LN" = x; then
9004             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9005           fi
9006         else
9007           # Otherwise we believe it is a complete path. Use it as it is.
9008           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LN=$tool_specified" >&5
9009 $as_echo "$as_me: Will use user supplied tool LN=$tool_specified" >&6;}
9010           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LN" >&5
9011 $as_echo_n "checking for LN... " >&6; }
9012           if test ! -x "$tool_specified"; then
9013             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9014 $as_echo "not found" >&6; }
9015             as_fn_error $? "User supplied tool LN=$tool_specified does not exist or is not executable" "$LINENO" 5
9016           fi
9017           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9018 $as_echo "$tool_specified" >&6; }
9019         fi
9020       fi
9021     fi
9022 
9023   fi
9024 
9025 
9026 
9027   if test "x$LN" = x; then
9028     as_fn_error $? "Could not find required tool for LN" "$LINENO" 5
9029   fi
9030 
9031 
9032 
9033 
9034 
9035   # Publish this variable in the help.
9036 
9037 
9038   if [ -z "${LS+x}" ]; then
9039     # The variable is not set by user, try to locate tool using the code snippet
9040     for ac_prog in ls
9041 do
9042   # Extract the first word of "$ac_prog", so it can be a program name with args.
9043 set dummy $ac_prog; ac_word=$2
9044 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9045 $as_echo_n "checking for $ac_word... " >&6; }
9046 if ${ac_cv_path_LS+:} false; then :
9047   $as_echo_n "(cached) " >&6
9048 else
9049   case $LS in
9050   [\\/]* | ?:[\\/]*)
9051   ac_cv_path_LS="$LS" # Let the user override the test with a path.
9052   ;;
9053   *)
9054   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9055 for as_dir in $PATH
9056 do
9057   IFS=$as_save_IFS
9058   test -z "$as_dir" && as_dir=.
9059     for ac_exec_ext in '' $ac_executable_extensions; do
9060   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9061     ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
9062     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9063     break 2
9064   fi
9065 done
9066   done
9067 IFS=$as_save_IFS
9068 
9069   ;;
9070 esac
9071 fi
9072 LS=$ac_cv_path_LS
9073 if test -n "$LS"; then
9074   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
9075 $as_echo "$LS" >&6; }
9076 else
9077   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9078 $as_echo "no" >&6; }
9079 fi
9080 
9081 
9082   test -n "$LS" && break
9083 done
9084 
9085   else
9086     # The variable is set, but is it from the command line or the environment?
9087 
9088     # Try to remove the string !LS! from our list.
9089     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LS!/}
9090     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9091       # If it failed, the variable was not from the command line. Ignore it,
9092       # but warn the user (except for BASH, which is always set by the calling BASH).
9093       if test "xLS" != xBASH; then
9094         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LS from the environment. Use command line variables instead." >&5
9095 $as_echo "$as_me: WARNING: Ignoring value of LS from the environment. Use command line variables instead." >&2;}
9096       fi
9097       # Try to locate tool using the code snippet
9098       for ac_prog in ls
9099 do
9100   # Extract the first word of "$ac_prog", so it can be a program name with args.
9101 set dummy $ac_prog; ac_word=$2
9102 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9103 $as_echo_n "checking for $ac_word... " >&6; }
9104 if ${ac_cv_path_LS+:} false; then :
9105   $as_echo_n "(cached) " >&6
9106 else
9107   case $LS in
9108   [\\/]* | ?:[\\/]*)
9109   ac_cv_path_LS="$LS" # Let the user override the test with a path.
9110   ;;
9111   *)
9112   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9113 for as_dir in $PATH
9114 do
9115   IFS=$as_save_IFS
9116   test -z "$as_dir" && as_dir=.
9117     for ac_exec_ext in '' $ac_executable_extensions; do
9118   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9119     ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
9120     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9121     break 2
9122   fi
9123 done
9124   done
9125 IFS=$as_save_IFS
9126 
9127   ;;
9128 esac
9129 fi
9130 LS=$ac_cv_path_LS
9131 if test -n "$LS"; then
9132   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
9133 $as_echo "$LS" >&6; }
9134 else
9135   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9136 $as_echo "no" >&6; }
9137 fi
9138 
9139 
9140   test -n "$LS" && break
9141 done
9142 
9143     else
9144       # If it succeeded, then it was overridden by the user. We will use it
9145       # for the tool.
9146 
9147       # First remove it from the list of overridden variables, so we can test
9148       # for unknown variables in the end.
9149       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9150 
9151       # Check if we try to supply an empty value
9152       if test "x$LS" = x; then
9153         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool LS= (no value)" >&5
9154 $as_echo "$as_me: Setting user supplied tool LS= (no value)" >&6;}
9155         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LS" >&5
9156 $as_echo_n "checking for LS... " >&6; }
9157         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
9158 $as_echo "disabled" >&6; }
9159       else
9160         # Check if the provided tool contains a complete path.
9161         tool_specified="$LS"
9162         tool_basename="${tool_specified##*/}"
9163         if test "x$tool_basename" = "x$tool_specified"; then
9164           # A command without a complete path is provided, search $PATH.
9165           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LS=$tool_basename" >&5
9166 $as_echo "$as_me: Will search for user supplied tool LS=$tool_basename" >&6;}
9167           # Extract the first word of "$tool_basename", so it can be a program name with args.
9168 set dummy $tool_basename; ac_word=$2
9169 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9170 $as_echo_n "checking for $ac_word... " >&6; }
9171 if ${ac_cv_path_LS+:} false; then :
9172   $as_echo_n "(cached) " >&6
9173 else
9174   case $LS in
9175   [\\/]* | ?:[\\/]*)
9176   ac_cv_path_LS="$LS" # Let the user override the test with a path.
9177   ;;
9178   *)
9179   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9180 for as_dir in $PATH
9181 do
9182   IFS=$as_save_IFS
9183   test -z "$as_dir" && as_dir=.
9184     for ac_exec_ext in '' $ac_executable_extensions; do
9185   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9186     ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
9187     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9188     break 2
9189   fi
9190 done
9191   done
9192 IFS=$as_save_IFS
9193 
9194   ;;
9195 esac
9196 fi
9197 LS=$ac_cv_path_LS
9198 if test -n "$LS"; then
9199   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
9200 $as_echo "$LS" >&6; }
9201 else
9202   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9203 $as_echo "no" >&6; }
9204 fi
9205 
9206 
9207           if test "x$LS" = x; then
9208             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9209           fi
9210         else
9211           # Otherwise we believe it is a complete path. Use it as it is.
9212           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LS=$tool_specified" >&5
9213 $as_echo "$as_me: Will use user supplied tool LS=$tool_specified" >&6;}
9214           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LS" >&5
9215 $as_echo_n "checking for LS... " >&6; }
9216           if test ! -x "$tool_specified"; then
9217             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9218 $as_echo "not found" >&6; }
9219             as_fn_error $? "User supplied tool LS=$tool_specified does not exist or is not executable" "$LINENO" 5
9220           fi
9221           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9222 $as_echo "$tool_specified" >&6; }
9223         fi
9224       fi
9225     fi
9226 
9227   fi
9228 
9229 
9230 
9231   if test "x$LS" = x; then
9232     as_fn_error $? "Could not find required tool for LS" "$LINENO" 5
9233   fi
9234 
9235 
9236 
9237 
9238 
9239   # Publish this variable in the help.
9240 
9241 
9242   if [ -z "${MKDIR+x}" ]; then
9243     # The variable is not set by user, try to locate tool using the code snippet
9244     for ac_prog in mkdir
9245 do
9246   # Extract the first word of "$ac_prog", so it can be a program name with args.
9247 set dummy $ac_prog; ac_word=$2
9248 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9249 $as_echo_n "checking for $ac_word... " >&6; }
9250 if ${ac_cv_path_MKDIR+:} false; then :
9251   $as_echo_n "(cached) " >&6
9252 else
9253   case $MKDIR in
9254   [\\/]* | ?:[\\/]*)
9255   ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
9256   ;;
9257   *)
9258   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9259 for as_dir in $PATH
9260 do
9261   IFS=$as_save_IFS
9262   test -z "$as_dir" && as_dir=.
9263     for ac_exec_ext in '' $ac_executable_extensions; do
9264   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9265     ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
9266     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9267     break 2
9268   fi
9269 done
9270   done
9271 IFS=$as_save_IFS
9272 
9273   ;;
9274 esac
9275 fi
9276 MKDIR=$ac_cv_path_MKDIR
9277 if test -n "$MKDIR"; then
9278   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
9279 $as_echo "$MKDIR" >&6; }
9280 else
9281   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9282 $as_echo "no" >&6; }
9283 fi
9284 
9285 
9286   test -n "$MKDIR" && break
9287 done
9288 
9289   else
9290     # The variable is set, but is it from the command line or the environment?
9291 
9292     # Try to remove the string !MKDIR! from our list.
9293     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MKDIR!/}
9294     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9295       # If it failed, the variable was not from the command line. Ignore it,
9296       # but warn the user (except for BASH, which is always set by the calling BASH).
9297       if test "xMKDIR" != xBASH; then
9298         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MKDIR from the environment. Use command line variables instead." >&5
9299 $as_echo "$as_me: WARNING: Ignoring value of MKDIR from the environment. Use command line variables instead." >&2;}
9300       fi
9301       # Try to locate tool using the code snippet
9302       for ac_prog in mkdir
9303 do
9304   # Extract the first word of "$ac_prog", so it can be a program name with args.
9305 set dummy $ac_prog; ac_word=$2
9306 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9307 $as_echo_n "checking for $ac_word... " >&6; }
9308 if ${ac_cv_path_MKDIR+:} false; then :
9309   $as_echo_n "(cached) " >&6
9310 else
9311   case $MKDIR in
9312   [\\/]* | ?:[\\/]*)
9313   ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
9314   ;;
9315   *)
9316   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9317 for as_dir in $PATH
9318 do
9319   IFS=$as_save_IFS
9320   test -z "$as_dir" && as_dir=.
9321     for ac_exec_ext in '' $ac_executable_extensions; do
9322   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9323     ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
9324     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9325     break 2
9326   fi
9327 done
9328   done
9329 IFS=$as_save_IFS
9330 
9331   ;;
9332 esac
9333 fi
9334 MKDIR=$ac_cv_path_MKDIR
9335 if test -n "$MKDIR"; then
9336   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
9337 $as_echo "$MKDIR" >&6; }
9338 else
9339   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9340 $as_echo "no" >&6; }
9341 fi
9342 
9343 
9344   test -n "$MKDIR" && break
9345 done
9346 
9347     else
9348       # If it succeeded, then it was overridden by the user. We will use it
9349       # for the tool.
9350 
9351       # First remove it from the list of overridden variables, so we can test
9352       # for unknown variables in the end.
9353       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9354 
9355       # Check if we try to supply an empty value
9356       if test "x$MKDIR" = x; then
9357         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool MKDIR= (no value)" >&5
9358 $as_echo "$as_me: Setting user supplied tool MKDIR= (no value)" >&6;}
9359         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKDIR" >&5
9360 $as_echo_n "checking for MKDIR... " >&6; }
9361         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
9362 $as_echo "disabled" >&6; }
9363       else
9364         # Check if the provided tool contains a complete path.
9365         tool_specified="$MKDIR"
9366         tool_basename="${tool_specified##*/}"
9367         if test "x$tool_basename" = "x$tool_specified"; then
9368           # A command without a complete path is provided, search $PATH.
9369           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MKDIR=$tool_basename" >&5
9370 $as_echo "$as_me: Will search for user supplied tool MKDIR=$tool_basename" >&6;}
9371           # Extract the first word of "$tool_basename", so it can be a program name with args.
9372 set dummy $tool_basename; ac_word=$2
9373 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9374 $as_echo_n "checking for $ac_word... " >&6; }
9375 if ${ac_cv_path_MKDIR+:} false; then :
9376   $as_echo_n "(cached) " >&6
9377 else
9378   case $MKDIR in
9379   [\\/]* | ?:[\\/]*)
9380   ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
9381   ;;
9382   *)
9383   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9384 for as_dir in $PATH
9385 do
9386   IFS=$as_save_IFS
9387   test -z "$as_dir" && as_dir=.
9388     for ac_exec_ext in '' $ac_executable_extensions; do
9389   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9390     ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
9391     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9392     break 2
9393   fi
9394 done
9395   done
9396 IFS=$as_save_IFS
9397 
9398   ;;
9399 esac
9400 fi
9401 MKDIR=$ac_cv_path_MKDIR
9402 if test -n "$MKDIR"; then
9403   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
9404 $as_echo "$MKDIR" >&6; }
9405 else
9406   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9407 $as_echo "no" >&6; }
9408 fi
9409 
9410 
9411           if test "x$MKDIR" = x; then
9412             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9413           fi
9414         else
9415           # Otherwise we believe it is a complete path. Use it as it is.
9416           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MKDIR=$tool_specified" >&5
9417 $as_echo "$as_me: Will use user supplied tool MKDIR=$tool_specified" >&6;}
9418           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKDIR" >&5
9419 $as_echo_n "checking for MKDIR... " >&6; }
9420           if test ! -x "$tool_specified"; then
9421             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9422 $as_echo "not found" >&6; }
9423             as_fn_error $? "User supplied tool MKDIR=$tool_specified does not exist or is not executable" "$LINENO" 5
9424           fi
9425           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9426 $as_echo "$tool_specified" >&6; }
9427         fi
9428       fi
9429     fi
9430 
9431   fi
9432 
9433 
9434 
9435   if test "x$MKDIR" = x; then
9436     as_fn_error $? "Could not find required tool for MKDIR" "$LINENO" 5
9437   fi
9438 
9439 
9440 
9441 
9442 
9443   # Publish this variable in the help.
9444 
9445 
9446   if [ -z "${MKTEMP+x}" ]; then
9447     # The variable is not set by user, try to locate tool using the code snippet
9448     for ac_prog in mktemp
9449 do
9450   # Extract the first word of "$ac_prog", so it can be a program name with args.
9451 set dummy $ac_prog; ac_word=$2
9452 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9453 $as_echo_n "checking for $ac_word... " >&6; }
9454 if ${ac_cv_path_MKTEMP+:} false; then :
9455   $as_echo_n "(cached) " >&6
9456 else
9457   case $MKTEMP in
9458   [\\/]* | ?:[\\/]*)
9459   ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
9460   ;;
9461   *)
9462   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9463 for as_dir in $PATH
9464 do
9465   IFS=$as_save_IFS
9466   test -z "$as_dir" && as_dir=.
9467     for ac_exec_ext in '' $ac_executable_extensions; do
9468   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9469     ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
9470     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9471     break 2
9472   fi
9473 done
9474   done
9475 IFS=$as_save_IFS
9476 
9477   ;;
9478 esac
9479 fi
9480 MKTEMP=$ac_cv_path_MKTEMP
9481 if test -n "$MKTEMP"; then
9482   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
9483 $as_echo "$MKTEMP" >&6; }
9484 else
9485   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9486 $as_echo "no" >&6; }
9487 fi
9488 
9489 
9490   test -n "$MKTEMP" && break
9491 done
9492 
9493   else
9494     # The variable is set, but is it from the command line or the environment?
9495 
9496     # Try to remove the string !MKTEMP! from our list.
9497     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MKTEMP!/}
9498     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9499       # If it failed, the variable was not from the command line. Ignore it,
9500       # but warn the user (except for BASH, which is always set by the calling BASH).
9501       if test "xMKTEMP" != xBASH; then
9502         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MKTEMP from the environment. Use command line variables instead." >&5
9503 $as_echo "$as_me: WARNING: Ignoring value of MKTEMP from the environment. Use command line variables instead." >&2;}
9504       fi
9505       # Try to locate tool using the code snippet
9506       for ac_prog in mktemp
9507 do
9508   # Extract the first word of "$ac_prog", so it can be a program name with args.
9509 set dummy $ac_prog; ac_word=$2
9510 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9511 $as_echo_n "checking for $ac_word... " >&6; }
9512 if ${ac_cv_path_MKTEMP+:} false; then :
9513   $as_echo_n "(cached) " >&6
9514 else
9515   case $MKTEMP in
9516   [\\/]* | ?:[\\/]*)
9517   ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
9518   ;;
9519   *)
9520   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9521 for as_dir in $PATH
9522 do
9523   IFS=$as_save_IFS
9524   test -z "$as_dir" && as_dir=.
9525     for ac_exec_ext in '' $ac_executable_extensions; do
9526   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9527     ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
9528     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9529     break 2
9530   fi
9531 done
9532   done
9533 IFS=$as_save_IFS
9534 
9535   ;;
9536 esac
9537 fi
9538 MKTEMP=$ac_cv_path_MKTEMP
9539 if test -n "$MKTEMP"; then
9540   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
9541 $as_echo "$MKTEMP" >&6; }
9542 else
9543   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9544 $as_echo "no" >&6; }
9545 fi
9546 
9547 
9548   test -n "$MKTEMP" && break
9549 done
9550 
9551     else
9552       # If it succeeded, then it was overridden by the user. We will use it
9553       # for the tool.
9554 
9555       # First remove it from the list of overridden variables, so we can test
9556       # for unknown variables in the end.
9557       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9558 
9559       # Check if we try to supply an empty value
9560       if test "x$MKTEMP" = x; then
9561         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool MKTEMP= (no value)" >&5
9562 $as_echo "$as_me: Setting user supplied tool MKTEMP= (no value)" >&6;}
9563         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKTEMP" >&5
9564 $as_echo_n "checking for MKTEMP... " >&6; }
9565         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
9566 $as_echo "disabled" >&6; }
9567       else
9568         # Check if the provided tool contains a complete path.
9569         tool_specified="$MKTEMP"
9570         tool_basename="${tool_specified##*/}"
9571         if test "x$tool_basename" = "x$tool_specified"; then
9572           # A command without a complete path is provided, search $PATH.
9573           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MKTEMP=$tool_basename" >&5
9574 $as_echo "$as_me: Will search for user supplied tool MKTEMP=$tool_basename" >&6;}
9575           # Extract the first word of "$tool_basename", so it can be a program name with args.
9576 set dummy $tool_basename; ac_word=$2
9577 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9578 $as_echo_n "checking for $ac_word... " >&6; }
9579 if ${ac_cv_path_MKTEMP+:} false; then :
9580   $as_echo_n "(cached) " >&6
9581 else
9582   case $MKTEMP in
9583   [\\/]* | ?:[\\/]*)
9584   ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
9585   ;;
9586   *)
9587   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9588 for as_dir in $PATH
9589 do
9590   IFS=$as_save_IFS
9591   test -z "$as_dir" && as_dir=.
9592     for ac_exec_ext in '' $ac_executable_extensions; do
9593   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9594     ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
9595     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9596     break 2
9597   fi
9598 done
9599   done
9600 IFS=$as_save_IFS
9601 
9602   ;;
9603 esac
9604 fi
9605 MKTEMP=$ac_cv_path_MKTEMP
9606 if test -n "$MKTEMP"; then
9607   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
9608 $as_echo "$MKTEMP" >&6; }
9609 else
9610   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9611 $as_echo "no" >&6; }
9612 fi
9613 
9614 
9615           if test "x$MKTEMP" = x; then
9616             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9617           fi
9618         else
9619           # Otherwise we believe it is a complete path. Use it as it is.
9620           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MKTEMP=$tool_specified" >&5
9621 $as_echo "$as_me: Will use user supplied tool MKTEMP=$tool_specified" >&6;}
9622           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKTEMP" >&5
9623 $as_echo_n "checking for MKTEMP... " >&6; }
9624           if test ! -x "$tool_specified"; then
9625             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9626 $as_echo "not found" >&6; }
9627             as_fn_error $? "User supplied tool MKTEMP=$tool_specified does not exist or is not executable" "$LINENO" 5
9628           fi
9629           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9630 $as_echo "$tool_specified" >&6; }
9631         fi
9632       fi
9633     fi
9634 
9635   fi
9636 
9637 
9638 
9639   if test "x$MKTEMP" = x; then
9640     as_fn_error $? "Could not find required tool for MKTEMP" "$LINENO" 5
9641   fi
9642 
9643 
9644 
9645 
9646 
9647   # Publish this variable in the help.
9648 
9649 
9650   if [ -z "${MV+x}" ]; then
9651     # The variable is not set by user, try to locate tool using the code snippet
9652     for ac_prog in mv
9653 do
9654   # Extract the first word of "$ac_prog", so it can be a program name with args.
9655 set dummy $ac_prog; ac_word=$2
9656 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9657 $as_echo_n "checking for $ac_word... " >&6; }
9658 if ${ac_cv_path_MV+:} false; then :
9659   $as_echo_n "(cached) " >&6
9660 else
9661   case $MV in
9662   [\\/]* | ?:[\\/]*)
9663   ac_cv_path_MV="$MV" # Let the user override the test with a path.
9664   ;;
9665   *)
9666   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9667 for as_dir in $PATH
9668 do
9669   IFS=$as_save_IFS
9670   test -z "$as_dir" && as_dir=.
9671     for ac_exec_ext in '' $ac_executable_extensions; do
9672   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9673     ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
9674     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9675     break 2
9676   fi
9677 done
9678   done
9679 IFS=$as_save_IFS
9680 
9681   ;;
9682 esac
9683 fi
9684 MV=$ac_cv_path_MV
9685 if test -n "$MV"; then
9686   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
9687 $as_echo "$MV" >&6; }
9688 else
9689   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9690 $as_echo "no" >&6; }
9691 fi
9692 
9693 
9694   test -n "$MV" && break
9695 done
9696 
9697   else
9698     # The variable is set, but is it from the command line or the environment?
9699 
9700     # Try to remove the string !MV! from our list.
9701     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MV!/}
9702     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9703       # If it failed, the variable was not from the command line. Ignore it,
9704       # but warn the user (except for BASH, which is always set by the calling BASH).
9705       if test "xMV" != xBASH; then
9706         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MV from the environment. Use command line variables instead." >&5
9707 $as_echo "$as_me: WARNING: Ignoring value of MV from the environment. Use command line variables instead." >&2;}
9708       fi
9709       # Try to locate tool using the code snippet
9710       for ac_prog in mv
9711 do
9712   # Extract the first word of "$ac_prog", so it can be a program name with args.
9713 set dummy $ac_prog; ac_word=$2
9714 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9715 $as_echo_n "checking for $ac_word... " >&6; }
9716 if ${ac_cv_path_MV+:} false; then :
9717   $as_echo_n "(cached) " >&6
9718 else
9719   case $MV in
9720   [\\/]* | ?:[\\/]*)
9721   ac_cv_path_MV="$MV" # Let the user override the test with a path.
9722   ;;
9723   *)
9724   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9725 for as_dir in $PATH
9726 do
9727   IFS=$as_save_IFS
9728   test -z "$as_dir" && as_dir=.
9729     for ac_exec_ext in '' $ac_executable_extensions; do
9730   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9731     ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
9732     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9733     break 2
9734   fi
9735 done
9736   done
9737 IFS=$as_save_IFS
9738 
9739   ;;
9740 esac
9741 fi
9742 MV=$ac_cv_path_MV
9743 if test -n "$MV"; then
9744   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
9745 $as_echo "$MV" >&6; }
9746 else
9747   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9748 $as_echo "no" >&6; }
9749 fi
9750 
9751 
9752   test -n "$MV" && break
9753 done
9754 
9755     else
9756       # If it succeeded, then it was overridden by the user. We will use it
9757       # for the tool.
9758 
9759       # First remove it from the list of overridden variables, so we can test
9760       # for unknown variables in the end.
9761       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9762 
9763       # Check if we try to supply an empty value
9764       if test "x$MV" = x; then
9765         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool MV= (no value)" >&5
9766 $as_echo "$as_me: Setting user supplied tool MV= (no value)" >&6;}
9767         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MV" >&5
9768 $as_echo_n "checking for MV... " >&6; }
9769         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
9770 $as_echo "disabled" >&6; }
9771       else
9772         # Check if the provided tool contains a complete path.
9773         tool_specified="$MV"
9774         tool_basename="${tool_specified##*/}"
9775         if test "x$tool_basename" = "x$tool_specified"; then
9776           # A command without a complete path is provided, search $PATH.
9777           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MV=$tool_basename" >&5
9778 $as_echo "$as_me: Will search for user supplied tool MV=$tool_basename" >&6;}
9779           # Extract the first word of "$tool_basename", so it can be a program name with args.
9780 set dummy $tool_basename; ac_word=$2
9781 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9782 $as_echo_n "checking for $ac_word... " >&6; }
9783 if ${ac_cv_path_MV+:} false; then :
9784   $as_echo_n "(cached) " >&6
9785 else
9786   case $MV in
9787   [\\/]* | ?:[\\/]*)
9788   ac_cv_path_MV="$MV" # Let the user override the test with a path.
9789   ;;
9790   *)
9791   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9792 for as_dir in $PATH
9793 do
9794   IFS=$as_save_IFS
9795   test -z "$as_dir" && as_dir=.
9796     for ac_exec_ext in '' $ac_executable_extensions; do
9797   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9798     ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
9799     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9800     break 2
9801   fi
9802 done
9803   done
9804 IFS=$as_save_IFS
9805 
9806   ;;
9807 esac
9808 fi
9809 MV=$ac_cv_path_MV
9810 if test -n "$MV"; then
9811   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
9812 $as_echo "$MV" >&6; }
9813 else
9814   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9815 $as_echo "no" >&6; }
9816 fi
9817 
9818 
9819           if test "x$MV" = x; then
9820             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9821           fi
9822         else
9823           # Otherwise we believe it is a complete path. Use it as it is.
9824           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MV=$tool_specified" >&5
9825 $as_echo "$as_me: Will use user supplied tool MV=$tool_specified" >&6;}
9826           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MV" >&5
9827 $as_echo_n "checking for MV... " >&6; }
9828           if test ! -x "$tool_specified"; then
9829             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9830 $as_echo "not found" >&6; }
9831             as_fn_error $? "User supplied tool MV=$tool_specified does not exist or is not executable" "$LINENO" 5
9832           fi
9833           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9834 $as_echo "$tool_specified" >&6; }
9835         fi
9836       fi
9837     fi
9838 
9839   fi
9840 
9841 
9842 
9843   if test "x$MV" = x; then
9844     as_fn_error $? "Could not find required tool for MV" "$LINENO" 5
9845   fi
9846 
9847 
9848 
9849 
9850 
9851   # Publish this variable in the help.
9852 
9853 
9854   if [ -z "${NAWK+x}" ]; then
9855     # The variable is not set by user, try to locate tool using the code snippet
9856     for ac_prog in nawk gawk awk
9857 do
9858   # Extract the first word of "$ac_prog", so it can be a program name with args.
9859 set dummy $ac_prog; ac_word=$2
9860 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9861 $as_echo_n "checking for $ac_word... " >&6; }
9862 if ${ac_cv_path_NAWK+:} false; then :
9863   $as_echo_n "(cached) " >&6
9864 else
9865   case $NAWK in
9866   [\\/]* | ?:[\\/]*)
9867   ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
9868   ;;
9869   *)
9870   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9871 for as_dir in $PATH
9872 do
9873   IFS=$as_save_IFS
9874   test -z "$as_dir" && as_dir=.
9875     for ac_exec_ext in '' $ac_executable_extensions; do
9876   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9877     ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
9878     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9879     break 2
9880   fi
9881 done
9882   done
9883 IFS=$as_save_IFS
9884 
9885   ;;
9886 esac
9887 fi
9888 NAWK=$ac_cv_path_NAWK
9889 if test -n "$NAWK"; then
9890   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
9891 $as_echo "$NAWK" >&6; }
9892 else
9893   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9894 $as_echo "no" >&6; }
9895 fi
9896 
9897 
9898   test -n "$NAWK" && break
9899 done
9900 
9901   else
9902     # The variable is set, but is it from the command line or the environment?
9903 
9904     # Try to remove the string !NAWK! from our list.
9905     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!NAWK!/}
9906     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9907       # If it failed, the variable was not from the command line. Ignore it,
9908       # but warn the user (except for BASH, which is always set by the calling BASH).
9909       if test "xNAWK" != xBASH; then
9910         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of NAWK from the environment. Use command line variables instead." >&5
9911 $as_echo "$as_me: WARNING: Ignoring value of NAWK from the environment. Use command line variables instead." >&2;}
9912       fi
9913       # Try to locate tool using the code snippet
9914       for ac_prog in nawk gawk awk
9915 do
9916   # Extract the first word of "$ac_prog", so it can be a program name with args.
9917 set dummy $ac_prog; ac_word=$2
9918 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9919 $as_echo_n "checking for $ac_word... " >&6; }
9920 if ${ac_cv_path_NAWK+:} false; then :
9921   $as_echo_n "(cached) " >&6
9922 else
9923   case $NAWK in
9924   [\\/]* | ?:[\\/]*)
9925   ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
9926   ;;
9927   *)
9928   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9929 for as_dir in $PATH
9930 do
9931   IFS=$as_save_IFS
9932   test -z "$as_dir" && as_dir=.
9933     for ac_exec_ext in '' $ac_executable_extensions; do
9934   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9935     ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
9936     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9937     break 2
9938   fi
9939 done
9940   done
9941 IFS=$as_save_IFS
9942 
9943   ;;
9944 esac
9945 fi
9946 NAWK=$ac_cv_path_NAWK
9947 if test -n "$NAWK"; then
9948   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
9949 $as_echo "$NAWK" >&6; }
9950 else
9951   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9952 $as_echo "no" >&6; }
9953 fi
9954 
9955 
9956   test -n "$NAWK" && break
9957 done
9958 
9959     else
9960       # If it succeeded, then it was overridden by the user. We will use it
9961       # for the tool.
9962 
9963       # First remove it from the list of overridden variables, so we can test
9964       # for unknown variables in the end.
9965       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9966 
9967       # Check if we try to supply an empty value
9968       if test "x$NAWK" = x; then
9969         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool NAWK= (no value)" >&5
9970 $as_echo "$as_me: Setting user supplied tool NAWK= (no value)" >&6;}
9971         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NAWK" >&5
9972 $as_echo_n "checking for NAWK... " >&6; }
9973         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
9974 $as_echo "disabled" >&6; }
9975       else
9976         # Check if the provided tool contains a complete path.
9977         tool_specified="$NAWK"
9978         tool_basename="${tool_specified##*/}"
9979         if test "x$tool_basename" = "x$tool_specified"; then
9980           # A command without a complete path is provided, search $PATH.
9981           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool NAWK=$tool_basename" >&5
9982 $as_echo "$as_me: Will search for user supplied tool NAWK=$tool_basename" >&6;}
9983           # Extract the first word of "$tool_basename", so it can be a program name with args.
9984 set dummy $tool_basename; ac_word=$2
9985 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9986 $as_echo_n "checking for $ac_word... " >&6; }
9987 if ${ac_cv_path_NAWK+:} false; then :
9988   $as_echo_n "(cached) " >&6
9989 else
9990   case $NAWK in
9991   [\\/]* | ?:[\\/]*)
9992   ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
9993   ;;
9994   *)
9995   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9996 for as_dir in $PATH
9997 do
9998   IFS=$as_save_IFS
9999   test -z "$as_dir" && as_dir=.
10000     for ac_exec_ext in '' $ac_executable_extensions; do
10001   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10002     ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
10003     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10004     break 2
10005   fi
10006 done
10007   done
10008 IFS=$as_save_IFS
10009 
10010   ;;
10011 esac
10012 fi
10013 NAWK=$ac_cv_path_NAWK
10014 if test -n "$NAWK"; then
10015   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
10016 $as_echo "$NAWK" >&6; }
10017 else
10018   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10019 $as_echo "no" >&6; }
10020 fi
10021 
10022 
10023           if test "x$NAWK" = x; then
10024             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10025           fi
10026         else
10027           # Otherwise we believe it is a complete path. Use it as it is.
10028           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool NAWK=$tool_specified" >&5
10029 $as_echo "$as_me: Will use user supplied tool NAWK=$tool_specified" >&6;}
10030           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NAWK" >&5
10031 $as_echo_n "checking for NAWK... " >&6; }
10032           if test ! -x "$tool_specified"; then
10033             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10034 $as_echo "not found" >&6; }
10035             as_fn_error $? "User supplied tool NAWK=$tool_specified does not exist or is not executable" "$LINENO" 5
10036           fi
10037           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10038 $as_echo "$tool_specified" >&6; }
10039         fi
10040       fi
10041     fi
10042 
10043   fi
10044 
10045 
10046 
10047   if test "x$NAWK" = x; then
10048     as_fn_error $? "Could not find required tool for NAWK" "$LINENO" 5
10049   fi
10050 
10051 
10052 
10053 
10054 
10055   # Publish this variable in the help.
10056 
10057 
10058   if [ -z "${PRINTF+x}" ]; then
10059     # The variable is not set by user, try to locate tool using the code snippet
10060     for ac_prog in printf
10061 do
10062   # Extract the first word of "$ac_prog", so it can be a program name with args.
10063 set dummy $ac_prog; ac_word=$2
10064 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10065 $as_echo_n "checking for $ac_word... " >&6; }
10066 if ${ac_cv_path_PRINTF+:} false; then :
10067   $as_echo_n "(cached) " >&6
10068 else
10069   case $PRINTF in
10070   [\\/]* | ?:[\\/]*)
10071   ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
10072   ;;
10073   *)
10074   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10075 for as_dir in $PATH
10076 do
10077   IFS=$as_save_IFS
10078   test -z "$as_dir" && as_dir=.
10079     for ac_exec_ext in '' $ac_executable_extensions; do
10080   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10081     ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
10082     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10083     break 2
10084   fi
10085 done
10086   done
10087 IFS=$as_save_IFS
10088 
10089   ;;
10090 esac
10091 fi
10092 PRINTF=$ac_cv_path_PRINTF
10093 if test -n "$PRINTF"; then
10094   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
10095 $as_echo "$PRINTF" >&6; }
10096 else
10097   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10098 $as_echo "no" >&6; }
10099 fi
10100 
10101 
10102   test -n "$PRINTF" && break
10103 done
10104 
10105   else
10106     # The variable is set, but is it from the command line or the environment?
10107 
10108     # Try to remove the string !PRINTF! from our list.
10109     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!PRINTF!/}
10110     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10111       # If it failed, the variable was not from the command line. Ignore it,
10112       # but warn the user (except for BASH, which is always set by the calling BASH).
10113       if test "xPRINTF" != xBASH; then
10114         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of PRINTF from the environment. Use command line variables instead." >&5
10115 $as_echo "$as_me: WARNING: Ignoring value of PRINTF from the environment. Use command line variables instead." >&2;}
10116       fi
10117       # Try to locate tool using the code snippet
10118       for ac_prog in printf
10119 do
10120   # Extract the first word of "$ac_prog", so it can be a program name with args.
10121 set dummy $ac_prog; ac_word=$2
10122 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10123 $as_echo_n "checking for $ac_word... " >&6; }
10124 if ${ac_cv_path_PRINTF+:} false; then :
10125   $as_echo_n "(cached) " >&6
10126 else
10127   case $PRINTF in
10128   [\\/]* | ?:[\\/]*)
10129   ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
10130   ;;
10131   *)
10132   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10133 for as_dir in $PATH
10134 do
10135   IFS=$as_save_IFS
10136   test -z "$as_dir" && as_dir=.
10137     for ac_exec_ext in '' $ac_executable_extensions; do
10138   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10139     ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
10140     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10141     break 2
10142   fi
10143 done
10144   done
10145 IFS=$as_save_IFS
10146 
10147   ;;
10148 esac
10149 fi
10150 PRINTF=$ac_cv_path_PRINTF
10151 if test -n "$PRINTF"; then
10152   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
10153 $as_echo "$PRINTF" >&6; }
10154 else
10155   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10156 $as_echo "no" >&6; }
10157 fi
10158 
10159 
10160   test -n "$PRINTF" && break
10161 done
10162 
10163     else
10164       # If it succeeded, then it was overridden by the user. We will use it
10165       # for the tool.
10166 
10167       # First remove it from the list of overridden variables, so we can test
10168       # for unknown variables in the end.
10169       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10170 
10171       # Check if we try to supply an empty value
10172       if test "x$PRINTF" = x; then
10173         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool PRINTF= (no value)" >&5
10174 $as_echo "$as_me: Setting user supplied tool PRINTF= (no value)" >&6;}
10175         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PRINTF" >&5
10176 $as_echo_n "checking for PRINTF... " >&6; }
10177         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
10178 $as_echo "disabled" >&6; }
10179       else
10180         # Check if the provided tool contains a complete path.
10181         tool_specified="$PRINTF"
10182         tool_basename="${tool_specified##*/}"
10183         if test "x$tool_basename" = "x$tool_specified"; then
10184           # A command without a complete path is provided, search $PATH.
10185           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool PRINTF=$tool_basename" >&5
10186 $as_echo "$as_me: Will search for user supplied tool PRINTF=$tool_basename" >&6;}
10187           # Extract the first word of "$tool_basename", so it can be a program name with args.
10188 set dummy $tool_basename; ac_word=$2
10189 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10190 $as_echo_n "checking for $ac_word... " >&6; }
10191 if ${ac_cv_path_PRINTF+:} false; then :
10192   $as_echo_n "(cached) " >&6
10193 else
10194   case $PRINTF in
10195   [\\/]* | ?:[\\/]*)
10196   ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
10197   ;;
10198   *)
10199   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10200 for as_dir in $PATH
10201 do
10202   IFS=$as_save_IFS
10203   test -z "$as_dir" && as_dir=.
10204     for ac_exec_ext in '' $ac_executable_extensions; do
10205   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10206     ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
10207     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10208     break 2
10209   fi
10210 done
10211   done
10212 IFS=$as_save_IFS
10213 
10214   ;;
10215 esac
10216 fi
10217 PRINTF=$ac_cv_path_PRINTF
10218 if test -n "$PRINTF"; then
10219   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
10220 $as_echo "$PRINTF" >&6; }
10221 else
10222   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10223 $as_echo "no" >&6; }
10224 fi
10225 
10226 
10227           if test "x$PRINTF" = x; then
10228             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10229           fi
10230         else
10231           # Otherwise we believe it is a complete path. Use it as it is.
10232           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool PRINTF=$tool_specified" >&5
10233 $as_echo "$as_me: Will use user supplied tool PRINTF=$tool_specified" >&6;}
10234           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PRINTF" >&5
10235 $as_echo_n "checking for PRINTF... " >&6; }
10236           if test ! -x "$tool_specified"; then
10237             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10238 $as_echo "not found" >&6; }
10239             as_fn_error $? "User supplied tool PRINTF=$tool_specified does not exist or is not executable" "$LINENO" 5
10240           fi
10241           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10242 $as_echo "$tool_specified" >&6; }
10243         fi
10244       fi
10245     fi
10246 
10247   fi
10248 
10249 
10250 
10251   if test "x$PRINTF" = x; then
10252     as_fn_error $? "Could not find required tool for PRINTF" "$LINENO" 5
10253   fi
10254 
10255 
10256 
10257 
10258 
10259   # Publish this variable in the help.
10260 
10261 
10262   if [ -z "${RM+x}" ]; then
10263     # The variable is not set by user, try to locate tool using the code snippet
10264     for ac_prog in rm
10265 do
10266   # Extract the first word of "$ac_prog", so it can be a program name with args.
10267 set dummy $ac_prog; ac_word=$2
10268 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10269 $as_echo_n "checking for $ac_word... " >&6; }
10270 if ${ac_cv_path_RM+:} false; then :
10271   $as_echo_n "(cached) " >&6
10272 else
10273   case $RM in
10274   [\\/]* | ?:[\\/]*)
10275   ac_cv_path_RM="$RM" # Let the user override the test with a path.
10276   ;;
10277   *)
10278   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10279 for as_dir in $PATH
10280 do
10281   IFS=$as_save_IFS
10282   test -z "$as_dir" && as_dir=.
10283     for ac_exec_ext in '' $ac_executable_extensions; do
10284   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10285     ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
10286     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10287     break 2
10288   fi
10289 done
10290   done
10291 IFS=$as_save_IFS
10292 
10293   ;;
10294 esac
10295 fi
10296 RM=$ac_cv_path_RM
10297 if test -n "$RM"; then
10298   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
10299 $as_echo "$RM" >&6; }
10300 else
10301   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10302 $as_echo "no" >&6; }
10303 fi
10304 
10305 
10306   test -n "$RM" && break
10307 done
10308 
10309   else
10310     # The variable is set, but is it from the command line or the environment?
10311 
10312     # Try to remove the string !RM! from our list.
10313     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!RM!/}
10314     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10315       # If it failed, the variable was not from the command line. Ignore it,
10316       # but warn the user (except for BASH, which is always set by the calling BASH).
10317       if test "xRM" != xBASH; then
10318         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of RM from the environment. Use command line variables instead." >&5
10319 $as_echo "$as_me: WARNING: Ignoring value of RM from the environment. Use command line variables instead." >&2;}
10320       fi
10321       # Try to locate tool using the code snippet
10322       for ac_prog in rm
10323 do
10324   # Extract the first word of "$ac_prog", so it can be a program name with args.
10325 set dummy $ac_prog; ac_word=$2
10326 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10327 $as_echo_n "checking for $ac_word... " >&6; }
10328 if ${ac_cv_path_RM+:} false; then :
10329   $as_echo_n "(cached) " >&6
10330 else
10331   case $RM in
10332   [\\/]* | ?:[\\/]*)
10333   ac_cv_path_RM="$RM" # Let the user override the test with a path.
10334   ;;
10335   *)
10336   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10337 for as_dir in $PATH
10338 do
10339   IFS=$as_save_IFS
10340   test -z "$as_dir" && as_dir=.
10341     for ac_exec_ext in '' $ac_executable_extensions; do
10342   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10343     ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
10344     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10345     break 2
10346   fi
10347 done
10348   done
10349 IFS=$as_save_IFS
10350 
10351   ;;
10352 esac
10353 fi
10354 RM=$ac_cv_path_RM
10355 if test -n "$RM"; then
10356   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
10357 $as_echo "$RM" >&6; }
10358 else
10359   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10360 $as_echo "no" >&6; }
10361 fi
10362 
10363 
10364   test -n "$RM" && break
10365 done
10366 
10367     else
10368       # If it succeeded, then it was overridden by the user. We will use it
10369       # for the tool.
10370 
10371       # First remove it from the list of overridden variables, so we can test
10372       # for unknown variables in the end.
10373       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10374 
10375       # Check if we try to supply an empty value
10376       if test "x$RM" = x; then
10377         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool RM= (no value)" >&5
10378 $as_echo "$as_me: Setting user supplied tool RM= (no value)" >&6;}
10379         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for RM" >&5
10380 $as_echo_n "checking for RM... " >&6; }
10381         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
10382 $as_echo "disabled" >&6; }
10383       else
10384         # Check if the provided tool contains a complete path.
10385         tool_specified="$RM"
10386         tool_basename="${tool_specified##*/}"
10387         if test "x$tool_basename" = "x$tool_specified"; then
10388           # A command without a complete path is provided, search $PATH.
10389           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool RM=$tool_basename" >&5
10390 $as_echo "$as_me: Will search for user supplied tool RM=$tool_basename" >&6;}
10391           # Extract the first word of "$tool_basename", so it can be a program name with args.
10392 set dummy $tool_basename; ac_word=$2
10393 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10394 $as_echo_n "checking for $ac_word... " >&6; }
10395 if ${ac_cv_path_RM+:} false; then :
10396   $as_echo_n "(cached) " >&6
10397 else
10398   case $RM in
10399   [\\/]* | ?:[\\/]*)
10400   ac_cv_path_RM="$RM" # Let the user override the test with a path.
10401   ;;
10402   *)
10403   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10404 for as_dir in $PATH
10405 do
10406   IFS=$as_save_IFS
10407   test -z "$as_dir" && as_dir=.
10408     for ac_exec_ext in '' $ac_executable_extensions; do
10409   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10410     ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
10411     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10412     break 2
10413   fi
10414 done
10415   done
10416 IFS=$as_save_IFS
10417 
10418   ;;
10419 esac
10420 fi
10421 RM=$ac_cv_path_RM
10422 if test -n "$RM"; then
10423   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
10424 $as_echo "$RM" >&6; }
10425 else
10426   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10427 $as_echo "no" >&6; }
10428 fi
10429 
10430 
10431           if test "x$RM" = x; then
10432             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10433           fi
10434         else
10435           # Otherwise we believe it is a complete path. Use it as it is.
10436           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool RM=$tool_specified" >&5
10437 $as_echo "$as_me: Will use user supplied tool RM=$tool_specified" >&6;}
10438           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for RM" >&5
10439 $as_echo_n "checking for RM... " >&6; }
10440           if test ! -x "$tool_specified"; then
10441             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10442 $as_echo "not found" >&6; }
10443             as_fn_error $? "User supplied tool RM=$tool_specified does not exist or is not executable" "$LINENO" 5
10444           fi
10445           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10446 $as_echo "$tool_specified" >&6; }
10447         fi
10448       fi
10449     fi
10450 
10451   fi
10452 
10453 
10454 
10455   if test "x$RM" = x; then
10456     as_fn_error $? "Could not find required tool for RM" "$LINENO" 5
10457   fi
10458 
10459 
10460 
10461 
10462 
10463   # Publish this variable in the help.
10464 
10465 
10466   if [ -z "${RMDIR+x}" ]; then
10467     # The variable is not set by user, try to locate tool using the code snippet
10468     for ac_prog in rmdir
10469 do
10470   # Extract the first word of "$ac_prog", so it can be a program name with args.
10471 set dummy $ac_prog; ac_word=$2
10472 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10473 $as_echo_n "checking for $ac_word... " >&6; }
10474 if ${ac_cv_path_RMDIR+:} false; then :
10475   $as_echo_n "(cached) " >&6
10476 else
10477   case $RMDIR in
10478   [\\/]* | ?:[\\/]*)
10479   ac_cv_path_RMDIR="$RMDIR" # Let the user override the test with a path.
10480   ;;
10481   *)
10482   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10483 for as_dir in $PATH
10484 do
10485   IFS=$as_save_IFS
10486   test -z "$as_dir" && as_dir=.
10487     for ac_exec_ext in '' $ac_executable_extensions; do
10488   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10489     ac_cv_path_RMDIR="$as_dir/$ac_word$ac_exec_ext"
10490     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10491     break 2
10492   fi
10493 done
10494   done
10495 IFS=$as_save_IFS
10496 
10497   ;;
10498 esac
10499 fi
10500 RMDIR=$ac_cv_path_RMDIR
10501 if test -n "$RMDIR"; then
10502   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RMDIR" >&5
10503 $as_echo "$RMDIR" >&6; }
10504 else
10505   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10506 $as_echo "no" >&6; }
10507 fi
10508 
10509 
10510   test -n "$RMDIR" && break
10511 done
10512 
10513   else
10514     # The variable is set, but is it from the command line or the environment?
10515 
10516     # Try to remove the string !RMDIR! from our list.
10517     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!RMDIR!/}
10518     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10519       # If it failed, the variable was not from the command line. Ignore it,
10520       # but warn the user (except for BASH, which is always set by the calling BASH).
10521       if test "xRMDIR" != xBASH; then
10522         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of RMDIR from the environment. Use command line variables instead." >&5
10523 $as_echo "$as_me: WARNING: Ignoring value of RMDIR from the environment. Use command line variables instead." >&2;}
10524       fi
10525       # Try to locate tool using the code snippet
10526       for ac_prog in rmdir
10527 do
10528   # Extract the first word of "$ac_prog", so it can be a program name with args.
10529 set dummy $ac_prog; ac_word=$2
10530 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10531 $as_echo_n "checking for $ac_word... " >&6; }
10532 if ${ac_cv_path_RMDIR+:} false; then :
10533   $as_echo_n "(cached) " >&6
10534 else
10535   case $RMDIR in
10536   [\\/]* | ?:[\\/]*)
10537   ac_cv_path_RMDIR="$RMDIR" # Let the user override the test with a path.
10538   ;;
10539   *)
10540   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10541 for as_dir in $PATH
10542 do
10543   IFS=$as_save_IFS
10544   test -z "$as_dir" && as_dir=.
10545     for ac_exec_ext in '' $ac_executable_extensions; do
10546   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10547     ac_cv_path_RMDIR="$as_dir/$ac_word$ac_exec_ext"
10548     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10549     break 2
10550   fi
10551 done
10552   done
10553 IFS=$as_save_IFS
10554 
10555   ;;
10556 esac
10557 fi
10558 RMDIR=$ac_cv_path_RMDIR
10559 if test -n "$RMDIR"; then
10560   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RMDIR" >&5
10561 $as_echo "$RMDIR" >&6; }
10562 else
10563   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10564 $as_echo "no" >&6; }
10565 fi
10566 
10567 
10568   test -n "$RMDIR" && break
10569 done
10570 
10571     else
10572       # If it succeeded, then it was overridden by the user. We will use it
10573       # for the tool.
10574 
10575       # First remove it from the list of overridden variables, so we can test
10576       # for unknown variables in the end.
10577       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10578 
10579       # Check if we try to supply an empty value
10580       if test "x$RMDIR" = x; then
10581         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool RMDIR= (no value)" >&5
10582 $as_echo "$as_me: Setting user supplied tool RMDIR= (no value)" >&6;}
10583         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for RMDIR" >&5
10584 $as_echo_n "checking for RMDIR... " >&6; }
10585         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
10586 $as_echo "disabled" >&6; }
10587       else
10588         # Check if the provided tool contains a complete path.
10589         tool_specified="$RMDIR"
10590         tool_basename="${tool_specified##*/}"
10591         if test "x$tool_basename" = "x$tool_specified"; then
10592           # A command without a complete path is provided, search $PATH.
10593           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool RMDIR=$tool_basename" >&5
10594 $as_echo "$as_me: Will search for user supplied tool RMDIR=$tool_basename" >&6;}
10595           # Extract the first word of "$tool_basename", so it can be a program name with args.
10596 set dummy $tool_basename; ac_word=$2
10597 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10598 $as_echo_n "checking for $ac_word... " >&6; }
10599 if ${ac_cv_path_RMDIR+:} false; then :
10600   $as_echo_n "(cached) " >&6
10601 else
10602   case $RMDIR in
10603   [\\/]* | ?:[\\/]*)
10604   ac_cv_path_RMDIR="$RMDIR" # Let the user override the test with a path.
10605   ;;
10606   *)
10607   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10608 for as_dir in $PATH
10609 do
10610   IFS=$as_save_IFS
10611   test -z "$as_dir" && as_dir=.
10612     for ac_exec_ext in '' $ac_executable_extensions; do
10613   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10614     ac_cv_path_RMDIR="$as_dir/$ac_word$ac_exec_ext"
10615     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10616     break 2
10617   fi
10618 done
10619   done
10620 IFS=$as_save_IFS
10621 
10622   ;;
10623 esac
10624 fi
10625 RMDIR=$ac_cv_path_RMDIR
10626 if test -n "$RMDIR"; then
10627   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RMDIR" >&5
10628 $as_echo "$RMDIR" >&6; }
10629 else
10630   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10631 $as_echo "no" >&6; }
10632 fi
10633 
10634 
10635           if test "x$RMDIR" = x; then
10636             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10637           fi
10638         else
10639           # Otherwise we believe it is a complete path. Use it as it is.
10640           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool RMDIR=$tool_specified" >&5
10641 $as_echo "$as_me: Will use user supplied tool RMDIR=$tool_specified" >&6;}
10642           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for RMDIR" >&5
10643 $as_echo_n "checking for RMDIR... " >&6; }
10644           if test ! -x "$tool_specified"; then
10645             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10646 $as_echo "not found" >&6; }
10647             as_fn_error $? "User supplied tool RMDIR=$tool_specified does not exist or is not executable" "$LINENO" 5
10648           fi
10649           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10650 $as_echo "$tool_specified" >&6; }
10651         fi
10652       fi
10653     fi
10654 
10655   fi
10656 
10657 
10658 
10659   if test "x$RMDIR" = x; then
10660     as_fn_error $? "Could not find required tool for RMDIR" "$LINENO" 5
10661   fi
10662 
10663 
10664 
10665 
10666 
10667   # Publish this variable in the help.
10668 
10669 
10670   if [ -z "${SH+x}" ]; then
10671     # The variable is not set by user, try to locate tool using the code snippet
10672     for ac_prog in sh
10673 do
10674   # Extract the first word of "$ac_prog", so it can be a program name with args.
10675 set dummy $ac_prog; ac_word=$2
10676 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10677 $as_echo_n "checking for $ac_word... " >&6; }
10678 if ${ac_cv_path_SH+:} false; then :
10679   $as_echo_n "(cached) " >&6
10680 else
10681   case $SH in
10682   [\\/]* | ?:[\\/]*)
10683   ac_cv_path_SH="$SH" # Let the user override the test with a path.
10684   ;;
10685   *)
10686   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10687 for as_dir in $PATH
10688 do
10689   IFS=$as_save_IFS
10690   test -z "$as_dir" && as_dir=.
10691     for ac_exec_ext in '' $ac_executable_extensions; do
10692   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10693     ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
10694     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10695     break 2
10696   fi
10697 done
10698   done
10699 IFS=$as_save_IFS
10700 
10701   ;;
10702 esac
10703 fi
10704 SH=$ac_cv_path_SH
10705 if test -n "$SH"; then
10706   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
10707 $as_echo "$SH" >&6; }
10708 else
10709   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10710 $as_echo "no" >&6; }
10711 fi
10712 
10713 
10714   test -n "$SH" && break
10715 done
10716 
10717   else
10718     # The variable is set, but is it from the command line or the environment?
10719 
10720     # Try to remove the string !SH! from our list.
10721     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SH!/}
10722     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10723       # If it failed, the variable was not from the command line. Ignore it,
10724       # but warn the user (except for BASH, which is always set by the calling BASH).
10725       if test "xSH" != xBASH; then
10726         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SH from the environment. Use command line variables instead." >&5
10727 $as_echo "$as_me: WARNING: Ignoring value of SH from the environment. Use command line variables instead." >&2;}
10728       fi
10729       # Try to locate tool using the code snippet
10730       for ac_prog in sh
10731 do
10732   # Extract the first word of "$ac_prog", so it can be a program name with args.
10733 set dummy $ac_prog; ac_word=$2
10734 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10735 $as_echo_n "checking for $ac_word... " >&6; }
10736 if ${ac_cv_path_SH+:} false; then :
10737   $as_echo_n "(cached) " >&6
10738 else
10739   case $SH in
10740   [\\/]* | ?:[\\/]*)
10741   ac_cv_path_SH="$SH" # Let the user override the test with a path.
10742   ;;
10743   *)
10744   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10745 for as_dir in $PATH
10746 do
10747   IFS=$as_save_IFS
10748   test -z "$as_dir" && as_dir=.
10749     for ac_exec_ext in '' $ac_executable_extensions; do
10750   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10751     ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
10752     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10753     break 2
10754   fi
10755 done
10756   done
10757 IFS=$as_save_IFS
10758 
10759   ;;
10760 esac
10761 fi
10762 SH=$ac_cv_path_SH
10763 if test -n "$SH"; then
10764   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
10765 $as_echo "$SH" >&6; }
10766 else
10767   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10768 $as_echo "no" >&6; }
10769 fi
10770 
10771 
10772   test -n "$SH" && break
10773 done
10774 
10775     else
10776       # If it succeeded, then it was overridden by the user. We will use it
10777       # for the tool.
10778 
10779       # First remove it from the list of overridden variables, so we can test
10780       # for unknown variables in the end.
10781       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10782 
10783       # Check if we try to supply an empty value
10784       if test "x$SH" = x; then
10785         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool SH= (no value)" >&5
10786 $as_echo "$as_me: Setting user supplied tool SH= (no value)" >&6;}
10787         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SH" >&5
10788 $as_echo_n "checking for SH... " >&6; }
10789         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
10790 $as_echo "disabled" >&6; }
10791       else
10792         # Check if the provided tool contains a complete path.
10793         tool_specified="$SH"
10794         tool_basename="${tool_specified##*/}"
10795         if test "x$tool_basename" = "x$tool_specified"; then
10796           # A command without a complete path is provided, search $PATH.
10797           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SH=$tool_basename" >&5
10798 $as_echo "$as_me: Will search for user supplied tool SH=$tool_basename" >&6;}
10799           # Extract the first word of "$tool_basename", so it can be a program name with args.
10800 set dummy $tool_basename; ac_word=$2
10801 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10802 $as_echo_n "checking for $ac_word... " >&6; }
10803 if ${ac_cv_path_SH+:} false; then :
10804   $as_echo_n "(cached) " >&6
10805 else
10806   case $SH in
10807   [\\/]* | ?:[\\/]*)
10808   ac_cv_path_SH="$SH" # Let the user override the test with a path.
10809   ;;
10810   *)
10811   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10812 for as_dir in $PATH
10813 do
10814   IFS=$as_save_IFS
10815   test -z "$as_dir" && as_dir=.
10816     for ac_exec_ext in '' $ac_executable_extensions; do
10817   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10818     ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
10819     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10820     break 2
10821   fi
10822 done
10823   done
10824 IFS=$as_save_IFS
10825 
10826   ;;
10827 esac
10828 fi
10829 SH=$ac_cv_path_SH
10830 if test -n "$SH"; then
10831   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
10832 $as_echo "$SH" >&6; }
10833 else
10834   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10835 $as_echo "no" >&6; }
10836 fi
10837 
10838 
10839           if test "x$SH" = x; then
10840             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10841           fi
10842         else
10843           # Otherwise we believe it is a complete path. Use it as it is.
10844           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SH=$tool_specified" >&5
10845 $as_echo "$as_me: Will use user supplied tool SH=$tool_specified" >&6;}
10846           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SH" >&5
10847 $as_echo_n "checking for SH... " >&6; }
10848           if test ! -x "$tool_specified"; then
10849             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10850 $as_echo "not found" >&6; }
10851             as_fn_error $? "User supplied tool SH=$tool_specified does not exist or is not executable" "$LINENO" 5
10852           fi
10853           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10854 $as_echo "$tool_specified" >&6; }
10855         fi
10856       fi
10857     fi
10858 
10859   fi
10860 
10861 
10862 
10863   if test "x$SH" = x; then
10864     as_fn_error $? "Could not find required tool for SH" "$LINENO" 5
10865   fi
10866 
10867 
10868 
10869 
10870 
10871   # Publish this variable in the help.
10872 
10873 
10874   if [ -z "${SORT+x}" ]; then
10875     # The variable is not set by user, try to locate tool using the code snippet
10876     for ac_prog in sort
10877 do
10878   # Extract the first word of "$ac_prog", so it can be a program name with args.
10879 set dummy $ac_prog; ac_word=$2
10880 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10881 $as_echo_n "checking for $ac_word... " >&6; }
10882 if ${ac_cv_path_SORT+:} false; then :
10883   $as_echo_n "(cached) " >&6
10884 else
10885   case $SORT in
10886   [\\/]* | ?:[\\/]*)
10887   ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
10888   ;;
10889   *)
10890   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10891 for as_dir in $PATH
10892 do
10893   IFS=$as_save_IFS
10894   test -z "$as_dir" && as_dir=.
10895     for ac_exec_ext in '' $ac_executable_extensions; do
10896   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10897     ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
10898     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10899     break 2
10900   fi
10901 done
10902   done
10903 IFS=$as_save_IFS
10904 
10905   ;;
10906 esac
10907 fi
10908 SORT=$ac_cv_path_SORT
10909 if test -n "$SORT"; then
10910   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
10911 $as_echo "$SORT" >&6; }
10912 else
10913   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10914 $as_echo "no" >&6; }
10915 fi
10916 
10917 
10918   test -n "$SORT" && break
10919 done
10920 
10921   else
10922     # The variable is set, but is it from the command line or the environment?
10923 
10924     # Try to remove the string !SORT! from our list.
10925     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SORT!/}
10926     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10927       # If it failed, the variable was not from the command line. Ignore it,
10928       # but warn the user (except for BASH, which is always set by the calling BASH).
10929       if test "xSORT" != xBASH; then
10930         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SORT from the environment. Use command line variables instead." >&5
10931 $as_echo "$as_me: WARNING: Ignoring value of SORT from the environment. Use command line variables instead." >&2;}
10932       fi
10933       # Try to locate tool using the code snippet
10934       for ac_prog in sort
10935 do
10936   # Extract the first word of "$ac_prog", so it can be a program name with args.
10937 set dummy $ac_prog; ac_word=$2
10938 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10939 $as_echo_n "checking for $ac_word... " >&6; }
10940 if ${ac_cv_path_SORT+:} false; then :
10941   $as_echo_n "(cached) " >&6
10942 else
10943   case $SORT in
10944   [\\/]* | ?:[\\/]*)
10945   ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
10946   ;;
10947   *)
10948   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10949 for as_dir in $PATH
10950 do
10951   IFS=$as_save_IFS
10952   test -z "$as_dir" && as_dir=.
10953     for ac_exec_ext in '' $ac_executable_extensions; do
10954   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10955     ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
10956     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10957     break 2
10958   fi
10959 done
10960   done
10961 IFS=$as_save_IFS
10962 
10963   ;;
10964 esac
10965 fi
10966 SORT=$ac_cv_path_SORT
10967 if test -n "$SORT"; then
10968   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
10969 $as_echo "$SORT" >&6; }
10970 else
10971   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10972 $as_echo "no" >&6; }
10973 fi
10974 
10975 
10976   test -n "$SORT" && break
10977 done
10978 
10979     else
10980       # If it succeeded, then it was overridden by the user. We will use it
10981       # for the tool.
10982 
10983       # First remove it from the list of overridden variables, so we can test
10984       # for unknown variables in the end.
10985       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10986 
10987       # Check if we try to supply an empty value
10988       if test "x$SORT" = x; then
10989         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool SORT= (no value)" >&5
10990 $as_echo "$as_me: Setting user supplied tool SORT= (no value)" >&6;}
10991         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SORT" >&5
10992 $as_echo_n "checking for SORT... " >&6; }
10993         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
10994 $as_echo "disabled" >&6; }
10995       else
10996         # Check if the provided tool contains a complete path.
10997         tool_specified="$SORT"
10998         tool_basename="${tool_specified##*/}"
10999         if test "x$tool_basename" = "x$tool_specified"; then
11000           # A command without a complete path is provided, search $PATH.
11001           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SORT=$tool_basename" >&5
11002 $as_echo "$as_me: Will search for user supplied tool SORT=$tool_basename" >&6;}
11003           # Extract the first word of "$tool_basename", so it can be a program name with args.
11004 set dummy $tool_basename; ac_word=$2
11005 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11006 $as_echo_n "checking for $ac_word... " >&6; }
11007 if ${ac_cv_path_SORT+:} false; then :
11008   $as_echo_n "(cached) " >&6
11009 else
11010   case $SORT in
11011   [\\/]* | ?:[\\/]*)
11012   ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
11013   ;;
11014   *)
11015   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11016 for as_dir in $PATH
11017 do
11018   IFS=$as_save_IFS
11019   test -z "$as_dir" && as_dir=.
11020     for ac_exec_ext in '' $ac_executable_extensions; do
11021   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11022     ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
11023     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11024     break 2
11025   fi
11026 done
11027   done
11028 IFS=$as_save_IFS
11029 
11030   ;;
11031 esac
11032 fi
11033 SORT=$ac_cv_path_SORT
11034 if test -n "$SORT"; then
11035   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
11036 $as_echo "$SORT" >&6; }
11037 else
11038   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11039 $as_echo "no" >&6; }
11040 fi
11041 
11042 
11043           if test "x$SORT" = x; then
11044             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11045           fi
11046         else
11047           # Otherwise we believe it is a complete path. Use it as it is.
11048           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SORT=$tool_specified" >&5
11049 $as_echo "$as_me: Will use user supplied tool SORT=$tool_specified" >&6;}
11050           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SORT" >&5
11051 $as_echo_n "checking for SORT... " >&6; }
11052           if test ! -x "$tool_specified"; then
11053             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11054 $as_echo "not found" >&6; }
11055             as_fn_error $? "User supplied tool SORT=$tool_specified does not exist or is not executable" "$LINENO" 5
11056           fi
11057           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11058 $as_echo "$tool_specified" >&6; }
11059         fi
11060       fi
11061     fi
11062 
11063   fi
11064 
11065 
11066 
11067   if test "x$SORT" = x; then
11068     as_fn_error $? "Could not find required tool for SORT" "$LINENO" 5
11069   fi
11070 
11071 
11072 
11073 
11074 
11075   # Publish this variable in the help.
11076 
11077 
11078   if [ -z "${TAIL+x}" ]; then
11079     # The variable is not set by user, try to locate tool using the code snippet
11080     for ac_prog in tail
11081 do
11082   # Extract the first word of "$ac_prog", so it can be a program name with args.
11083 set dummy $ac_prog; ac_word=$2
11084 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11085 $as_echo_n "checking for $ac_word... " >&6; }
11086 if ${ac_cv_path_TAIL+:} false; then :
11087   $as_echo_n "(cached) " >&6
11088 else
11089   case $TAIL in
11090   [\\/]* | ?:[\\/]*)
11091   ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
11092   ;;
11093   *)
11094   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11095 for as_dir in $PATH
11096 do
11097   IFS=$as_save_IFS
11098   test -z "$as_dir" && as_dir=.
11099     for ac_exec_ext in '' $ac_executable_extensions; do
11100   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11101     ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
11102     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11103     break 2
11104   fi
11105 done
11106   done
11107 IFS=$as_save_IFS
11108 
11109   ;;
11110 esac
11111 fi
11112 TAIL=$ac_cv_path_TAIL
11113 if test -n "$TAIL"; then
11114   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
11115 $as_echo "$TAIL" >&6; }
11116 else
11117   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11118 $as_echo "no" >&6; }
11119 fi
11120 
11121 
11122   test -n "$TAIL" && break
11123 done
11124 
11125   else
11126     # The variable is set, but is it from the command line or the environment?
11127 
11128     # Try to remove the string !TAIL! from our list.
11129     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TAIL!/}
11130     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11131       # If it failed, the variable was not from the command line. Ignore it,
11132       # but warn the user (except for BASH, which is always set by the calling BASH).
11133       if test "xTAIL" != xBASH; then
11134         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TAIL from the environment. Use command line variables instead." >&5
11135 $as_echo "$as_me: WARNING: Ignoring value of TAIL from the environment. Use command line variables instead." >&2;}
11136       fi
11137       # Try to locate tool using the code snippet
11138       for ac_prog in tail
11139 do
11140   # Extract the first word of "$ac_prog", so it can be a program name with args.
11141 set dummy $ac_prog; ac_word=$2
11142 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11143 $as_echo_n "checking for $ac_word... " >&6; }
11144 if ${ac_cv_path_TAIL+:} false; then :
11145   $as_echo_n "(cached) " >&6
11146 else
11147   case $TAIL in
11148   [\\/]* | ?:[\\/]*)
11149   ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
11150   ;;
11151   *)
11152   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11153 for as_dir in $PATH
11154 do
11155   IFS=$as_save_IFS
11156   test -z "$as_dir" && as_dir=.
11157     for ac_exec_ext in '' $ac_executable_extensions; do
11158   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11159     ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
11160     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11161     break 2
11162   fi
11163 done
11164   done
11165 IFS=$as_save_IFS
11166 
11167   ;;
11168 esac
11169 fi
11170 TAIL=$ac_cv_path_TAIL
11171 if test -n "$TAIL"; then
11172   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
11173 $as_echo "$TAIL" >&6; }
11174 else
11175   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11176 $as_echo "no" >&6; }
11177 fi
11178 
11179 
11180   test -n "$TAIL" && break
11181 done
11182 
11183     else
11184       # If it succeeded, then it was overridden by the user. We will use it
11185       # for the tool.
11186 
11187       # First remove it from the list of overridden variables, so we can test
11188       # for unknown variables in the end.
11189       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11190 
11191       # Check if we try to supply an empty value
11192       if test "x$TAIL" = x; then
11193         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool TAIL= (no value)" >&5
11194 $as_echo "$as_me: Setting user supplied tool TAIL= (no value)" >&6;}
11195         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAIL" >&5
11196 $as_echo_n "checking for TAIL... " >&6; }
11197         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
11198 $as_echo "disabled" >&6; }
11199       else
11200         # Check if the provided tool contains a complete path.
11201         tool_specified="$TAIL"
11202         tool_basename="${tool_specified##*/}"
11203         if test "x$tool_basename" = "x$tool_specified"; then
11204           # A command without a complete path is provided, search $PATH.
11205           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TAIL=$tool_basename" >&5
11206 $as_echo "$as_me: Will search for user supplied tool TAIL=$tool_basename" >&6;}
11207           # Extract the first word of "$tool_basename", so it can be a program name with args.
11208 set dummy $tool_basename; ac_word=$2
11209 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11210 $as_echo_n "checking for $ac_word... " >&6; }
11211 if ${ac_cv_path_TAIL+:} false; then :
11212   $as_echo_n "(cached) " >&6
11213 else
11214   case $TAIL in
11215   [\\/]* | ?:[\\/]*)
11216   ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
11217   ;;
11218   *)
11219   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11220 for as_dir in $PATH
11221 do
11222   IFS=$as_save_IFS
11223   test -z "$as_dir" && as_dir=.
11224     for ac_exec_ext in '' $ac_executable_extensions; do
11225   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11226     ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
11227     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11228     break 2
11229   fi
11230 done
11231   done
11232 IFS=$as_save_IFS
11233 
11234   ;;
11235 esac
11236 fi
11237 TAIL=$ac_cv_path_TAIL
11238 if test -n "$TAIL"; then
11239   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
11240 $as_echo "$TAIL" >&6; }
11241 else
11242   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11243 $as_echo "no" >&6; }
11244 fi
11245 
11246 
11247           if test "x$TAIL" = x; then
11248             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11249           fi
11250         else
11251           # Otherwise we believe it is a complete path. Use it as it is.
11252           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TAIL=$tool_specified" >&5
11253 $as_echo "$as_me: Will use user supplied tool TAIL=$tool_specified" >&6;}
11254           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAIL" >&5
11255 $as_echo_n "checking for TAIL... " >&6; }
11256           if test ! -x "$tool_specified"; then
11257             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11258 $as_echo "not found" >&6; }
11259             as_fn_error $? "User supplied tool TAIL=$tool_specified does not exist or is not executable" "$LINENO" 5
11260           fi
11261           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11262 $as_echo "$tool_specified" >&6; }
11263         fi
11264       fi
11265     fi
11266 
11267   fi
11268 
11269 
11270 
11271   if test "x$TAIL" = x; then
11272     as_fn_error $? "Could not find required tool for TAIL" "$LINENO" 5
11273   fi
11274 
11275 
11276 
11277 
11278 
11279   # Publish this variable in the help.
11280 
11281 
11282   if [ -z "${TAR+x}" ]; then
11283     # The variable is not set by user, try to locate tool using the code snippet
11284     for ac_prog in gtar tar
11285 do
11286   # Extract the first word of "$ac_prog", so it can be a program name with args.
11287 set dummy $ac_prog; ac_word=$2
11288 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11289 $as_echo_n "checking for $ac_word... " >&6; }
11290 if ${ac_cv_path_TAR+:} false; then :
11291   $as_echo_n "(cached) " >&6
11292 else
11293   case $TAR in
11294   [\\/]* | ?:[\\/]*)
11295   ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
11296   ;;
11297   *)
11298   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11299 for as_dir in $PATH
11300 do
11301   IFS=$as_save_IFS
11302   test -z "$as_dir" && as_dir=.
11303     for ac_exec_ext in '' $ac_executable_extensions; do
11304   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11305     ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
11306     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11307     break 2
11308   fi
11309 done
11310   done
11311 IFS=$as_save_IFS
11312 
11313   ;;
11314 esac
11315 fi
11316 TAR=$ac_cv_path_TAR
11317 if test -n "$TAR"; then
11318   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
11319 $as_echo "$TAR" >&6; }
11320 else
11321   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11322 $as_echo "no" >&6; }
11323 fi
11324 
11325 
11326   test -n "$TAR" && break
11327 done
11328 
11329   else
11330     # The variable is set, but is it from the command line or the environment?
11331 
11332     # Try to remove the string !TAR! from our list.
11333     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TAR!/}
11334     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11335       # If it failed, the variable was not from the command line. Ignore it,
11336       # but warn the user (except for BASH, which is always set by the calling BASH).
11337       if test "xTAR" != xBASH; then
11338         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TAR from the environment. Use command line variables instead." >&5
11339 $as_echo "$as_me: WARNING: Ignoring value of TAR from the environment. Use command line variables instead." >&2;}
11340       fi
11341       # Try to locate tool using the code snippet
11342       for ac_prog in gtar tar
11343 do
11344   # Extract the first word of "$ac_prog", so it can be a program name with args.
11345 set dummy $ac_prog; ac_word=$2
11346 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11347 $as_echo_n "checking for $ac_word... " >&6; }
11348 if ${ac_cv_path_TAR+:} false; then :
11349   $as_echo_n "(cached) " >&6
11350 else
11351   case $TAR in
11352   [\\/]* | ?:[\\/]*)
11353   ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
11354   ;;
11355   *)
11356   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11357 for as_dir in $PATH
11358 do
11359   IFS=$as_save_IFS
11360   test -z "$as_dir" && as_dir=.
11361     for ac_exec_ext in '' $ac_executable_extensions; do
11362   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11363     ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
11364     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11365     break 2
11366   fi
11367 done
11368   done
11369 IFS=$as_save_IFS
11370 
11371   ;;
11372 esac
11373 fi
11374 TAR=$ac_cv_path_TAR
11375 if test -n "$TAR"; then
11376   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
11377 $as_echo "$TAR" >&6; }
11378 else
11379   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11380 $as_echo "no" >&6; }
11381 fi
11382 
11383 
11384   test -n "$TAR" && break
11385 done
11386 
11387     else
11388       # If it succeeded, then it was overridden by the user. We will use it
11389       # for the tool.
11390 
11391       # First remove it from the list of overridden variables, so we can test
11392       # for unknown variables in the end.
11393       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11394 
11395       # Check if we try to supply an empty value
11396       if test "x$TAR" = x; then
11397         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool TAR= (no value)" >&5
11398 $as_echo "$as_me: Setting user supplied tool TAR= (no value)" >&6;}
11399         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAR" >&5
11400 $as_echo_n "checking for TAR... " >&6; }
11401         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
11402 $as_echo "disabled" >&6; }
11403       else
11404         # Check if the provided tool contains a complete path.
11405         tool_specified="$TAR"
11406         tool_basename="${tool_specified##*/}"
11407         if test "x$tool_basename" = "x$tool_specified"; then
11408           # A command without a complete path is provided, search $PATH.
11409           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TAR=$tool_basename" >&5
11410 $as_echo "$as_me: Will search for user supplied tool TAR=$tool_basename" >&6;}
11411           # Extract the first word of "$tool_basename", so it can be a program name with args.
11412 set dummy $tool_basename; ac_word=$2
11413 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11414 $as_echo_n "checking for $ac_word... " >&6; }
11415 if ${ac_cv_path_TAR+:} false; then :
11416   $as_echo_n "(cached) " >&6
11417 else
11418   case $TAR in
11419   [\\/]* | ?:[\\/]*)
11420   ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
11421   ;;
11422   *)
11423   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11424 for as_dir in $PATH
11425 do
11426   IFS=$as_save_IFS
11427   test -z "$as_dir" && as_dir=.
11428     for ac_exec_ext in '' $ac_executable_extensions; do
11429   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11430     ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
11431     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11432     break 2
11433   fi
11434 done
11435   done
11436 IFS=$as_save_IFS
11437 
11438   ;;
11439 esac
11440 fi
11441 TAR=$ac_cv_path_TAR
11442 if test -n "$TAR"; then
11443   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
11444 $as_echo "$TAR" >&6; }
11445 else
11446   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11447 $as_echo "no" >&6; }
11448 fi
11449 
11450 
11451           if test "x$TAR" = x; then
11452             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11453           fi
11454         else
11455           # Otherwise we believe it is a complete path. Use it as it is.
11456           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TAR=$tool_specified" >&5
11457 $as_echo "$as_me: Will use user supplied tool TAR=$tool_specified" >&6;}
11458           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAR" >&5
11459 $as_echo_n "checking for TAR... " >&6; }
11460           if test ! -x "$tool_specified"; then
11461             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11462 $as_echo "not found" >&6; }
11463             as_fn_error $? "User supplied tool TAR=$tool_specified does not exist or is not executable" "$LINENO" 5
11464           fi
11465           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11466 $as_echo "$tool_specified" >&6; }
11467         fi
11468       fi
11469     fi
11470 
11471   fi
11472 
11473 
11474 
11475   if test "x$TAR" = x; then
11476     as_fn_error $? "Could not find required tool for TAR" "$LINENO" 5
11477   fi
11478 
11479 
11480 
11481 
11482 
11483   # Publish this variable in the help.
11484 
11485 
11486   if [ -z "${TEE+x}" ]; then
11487     # The variable is not set by user, try to locate tool using the code snippet
11488     for ac_prog in tee
11489 do
11490   # Extract the first word of "$ac_prog", so it can be a program name with args.
11491 set dummy $ac_prog; ac_word=$2
11492 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11493 $as_echo_n "checking for $ac_word... " >&6; }
11494 if ${ac_cv_path_TEE+:} false; then :
11495   $as_echo_n "(cached) " >&6
11496 else
11497   case $TEE in
11498   [\\/]* | ?:[\\/]*)
11499   ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
11500   ;;
11501   *)
11502   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11503 for as_dir in $PATH
11504 do
11505   IFS=$as_save_IFS
11506   test -z "$as_dir" && as_dir=.
11507     for ac_exec_ext in '' $ac_executable_extensions; do
11508   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11509     ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
11510     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11511     break 2
11512   fi
11513 done
11514   done
11515 IFS=$as_save_IFS
11516 
11517   ;;
11518 esac
11519 fi
11520 TEE=$ac_cv_path_TEE
11521 if test -n "$TEE"; then
11522   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
11523 $as_echo "$TEE" >&6; }
11524 else
11525   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11526 $as_echo "no" >&6; }
11527 fi
11528 
11529 
11530   test -n "$TEE" && break
11531 done
11532 
11533   else
11534     # The variable is set, but is it from the command line or the environment?
11535 
11536     # Try to remove the string !TEE! from our list.
11537     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TEE!/}
11538     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11539       # If it failed, the variable was not from the command line. Ignore it,
11540       # but warn the user (except for BASH, which is always set by the calling BASH).
11541       if test "xTEE" != xBASH; then
11542         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TEE from the environment. Use command line variables instead." >&5
11543 $as_echo "$as_me: WARNING: Ignoring value of TEE from the environment. Use command line variables instead." >&2;}
11544       fi
11545       # Try to locate tool using the code snippet
11546       for ac_prog in tee
11547 do
11548   # Extract the first word of "$ac_prog", so it can be a program name with args.
11549 set dummy $ac_prog; ac_word=$2
11550 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11551 $as_echo_n "checking for $ac_word... " >&6; }
11552 if ${ac_cv_path_TEE+:} false; then :
11553   $as_echo_n "(cached) " >&6
11554 else
11555   case $TEE in
11556   [\\/]* | ?:[\\/]*)
11557   ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
11558   ;;
11559   *)
11560   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11561 for as_dir in $PATH
11562 do
11563   IFS=$as_save_IFS
11564   test -z "$as_dir" && as_dir=.
11565     for ac_exec_ext in '' $ac_executable_extensions; do
11566   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11567     ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
11568     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11569     break 2
11570   fi
11571 done
11572   done
11573 IFS=$as_save_IFS
11574 
11575   ;;
11576 esac
11577 fi
11578 TEE=$ac_cv_path_TEE
11579 if test -n "$TEE"; then
11580   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
11581 $as_echo "$TEE" >&6; }
11582 else
11583   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11584 $as_echo "no" >&6; }
11585 fi
11586 
11587 
11588   test -n "$TEE" && break
11589 done
11590 
11591     else
11592       # If it succeeded, then it was overridden by the user. We will use it
11593       # for the tool.
11594 
11595       # First remove it from the list of overridden variables, so we can test
11596       # for unknown variables in the end.
11597       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11598 
11599       # Check if we try to supply an empty value
11600       if test "x$TEE" = x; then
11601         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool TEE= (no value)" >&5
11602 $as_echo "$as_me: Setting user supplied tool TEE= (no value)" >&6;}
11603         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TEE" >&5
11604 $as_echo_n "checking for TEE... " >&6; }
11605         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
11606 $as_echo "disabled" >&6; }
11607       else
11608         # Check if the provided tool contains a complete path.
11609         tool_specified="$TEE"
11610         tool_basename="${tool_specified##*/}"
11611         if test "x$tool_basename" = "x$tool_specified"; then
11612           # A command without a complete path is provided, search $PATH.
11613           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TEE=$tool_basename" >&5
11614 $as_echo "$as_me: Will search for user supplied tool TEE=$tool_basename" >&6;}
11615           # Extract the first word of "$tool_basename", so it can be a program name with args.
11616 set dummy $tool_basename; ac_word=$2
11617 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11618 $as_echo_n "checking for $ac_word... " >&6; }
11619 if ${ac_cv_path_TEE+:} false; then :
11620   $as_echo_n "(cached) " >&6
11621 else
11622   case $TEE in
11623   [\\/]* | ?:[\\/]*)
11624   ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
11625   ;;
11626   *)
11627   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11628 for as_dir in $PATH
11629 do
11630   IFS=$as_save_IFS
11631   test -z "$as_dir" && as_dir=.
11632     for ac_exec_ext in '' $ac_executable_extensions; do
11633   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11634     ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
11635     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11636     break 2
11637   fi
11638 done
11639   done
11640 IFS=$as_save_IFS
11641 
11642   ;;
11643 esac
11644 fi
11645 TEE=$ac_cv_path_TEE
11646 if test -n "$TEE"; then
11647   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
11648 $as_echo "$TEE" >&6; }
11649 else
11650   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11651 $as_echo "no" >&6; }
11652 fi
11653 
11654 
11655           if test "x$TEE" = x; then
11656             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11657           fi
11658         else
11659           # Otherwise we believe it is a complete path. Use it as it is.
11660           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TEE=$tool_specified" >&5
11661 $as_echo "$as_me: Will use user supplied tool TEE=$tool_specified" >&6;}
11662           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TEE" >&5
11663 $as_echo_n "checking for TEE... " >&6; }
11664           if test ! -x "$tool_specified"; then
11665             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11666 $as_echo "not found" >&6; }
11667             as_fn_error $? "User supplied tool TEE=$tool_specified does not exist or is not executable" "$LINENO" 5
11668           fi
11669           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11670 $as_echo "$tool_specified" >&6; }
11671         fi
11672       fi
11673     fi
11674 
11675   fi
11676 
11677 
11678 
11679   if test "x$TEE" = x; then
11680     as_fn_error $? "Could not find required tool for TEE" "$LINENO" 5
11681   fi
11682 
11683 
11684 
11685 
11686 
11687   # Publish this variable in the help.
11688 
11689 
11690   if [ -z "${TOUCH+x}" ]; then
11691     # The variable is not set by user, try to locate tool using the code snippet
11692     for ac_prog in touch
11693 do
11694   # Extract the first word of "$ac_prog", so it can be a program name with args.
11695 set dummy $ac_prog; ac_word=$2
11696 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11697 $as_echo_n "checking for $ac_word... " >&6; }
11698 if ${ac_cv_path_TOUCH+:} false; then :
11699   $as_echo_n "(cached) " >&6
11700 else
11701   case $TOUCH in
11702   [\\/]* | ?:[\\/]*)
11703   ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
11704   ;;
11705   *)
11706   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11707 for as_dir in $PATH
11708 do
11709   IFS=$as_save_IFS
11710   test -z "$as_dir" && as_dir=.
11711     for ac_exec_ext in '' $ac_executable_extensions; do
11712   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11713     ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
11714     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11715     break 2
11716   fi
11717 done
11718   done
11719 IFS=$as_save_IFS
11720 
11721   ;;
11722 esac
11723 fi
11724 TOUCH=$ac_cv_path_TOUCH
11725 if test -n "$TOUCH"; then
11726   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
11727 $as_echo "$TOUCH" >&6; }
11728 else
11729   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11730 $as_echo "no" >&6; }
11731 fi
11732 
11733 
11734   test -n "$TOUCH" && break
11735 done
11736 
11737   else
11738     # The variable is set, but is it from the command line or the environment?
11739 
11740     # Try to remove the string !TOUCH! from our list.
11741     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TOUCH!/}
11742     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11743       # If it failed, the variable was not from the command line. Ignore it,
11744       # but warn the user (except for BASH, which is always set by the calling BASH).
11745       if test "xTOUCH" != xBASH; then
11746         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TOUCH from the environment. Use command line variables instead." >&5
11747 $as_echo "$as_me: WARNING: Ignoring value of TOUCH from the environment. Use command line variables instead." >&2;}
11748       fi
11749       # Try to locate tool using the code snippet
11750       for ac_prog in touch
11751 do
11752   # Extract the first word of "$ac_prog", so it can be a program name with args.
11753 set dummy $ac_prog; ac_word=$2
11754 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11755 $as_echo_n "checking for $ac_word... " >&6; }
11756 if ${ac_cv_path_TOUCH+:} false; then :
11757   $as_echo_n "(cached) " >&6
11758 else
11759   case $TOUCH in
11760   [\\/]* | ?:[\\/]*)
11761   ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
11762   ;;
11763   *)
11764   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11765 for as_dir in $PATH
11766 do
11767   IFS=$as_save_IFS
11768   test -z "$as_dir" && as_dir=.
11769     for ac_exec_ext in '' $ac_executable_extensions; do
11770   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11771     ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
11772     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11773     break 2
11774   fi
11775 done
11776   done
11777 IFS=$as_save_IFS
11778 
11779   ;;
11780 esac
11781 fi
11782 TOUCH=$ac_cv_path_TOUCH
11783 if test -n "$TOUCH"; then
11784   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
11785 $as_echo "$TOUCH" >&6; }
11786 else
11787   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11788 $as_echo "no" >&6; }
11789 fi
11790 
11791 
11792   test -n "$TOUCH" && break
11793 done
11794 
11795     else
11796       # If it succeeded, then it was overridden by the user. We will use it
11797       # for the tool.
11798 
11799       # First remove it from the list of overridden variables, so we can test
11800       # for unknown variables in the end.
11801       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11802 
11803       # Check if we try to supply an empty value
11804       if test "x$TOUCH" = x; then
11805         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool TOUCH= (no value)" >&5
11806 $as_echo "$as_me: Setting user supplied tool TOUCH= (no value)" >&6;}
11807         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TOUCH" >&5
11808 $as_echo_n "checking for TOUCH... " >&6; }
11809         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
11810 $as_echo "disabled" >&6; }
11811       else
11812         # Check if the provided tool contains a complete path.
11813         tool_specified="$TOUCH"
11814         tool_basename="${tool_specified##*/}"
11815         if test "x$tool_basename" = "x$tool_specified"; then
11816           # A command without a complete path is provided, search $PATH.
11817           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TOUCH=$tool_basename" >&5
11818 $as_echo "$as_me: Will search for user supplied tool TOUCH=$tool_basename" >&6;}
11819           # Extract the first word of "$tool_basename", so it can be a program name with args.
11820 set dummy $tool_basename; ac_word=$2
11821 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11822 $as_echo_n "checking for $ac_word... " >&6; }
11823 if ${ac_cv_path_TOUCH+:} false; then :
11824   $as_echo_n "(cached) " >&6
11825 else
11826   case $TOUCH in
11827   [\\/]* | ?:[\\/]*)
11828   ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
11829   ;;
11830   *)
11831   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11832 for as_dir in $PATH
11833 do
11834   IFS=$as_save_IFS
11835   test -z "$as_dir" && as_dir=.
11836     for ac_exec_ext in '' $ac_executable_extensions; do
11837   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11838     ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
11839     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11840     break 2
11841   fi
11842 done
11843   done
11844 IFS=$as_save_IFS
11845 
11846   ;;
11847 esac
11848 fi
11849 TOUCH=$ac_cv_path_TOUCH
11850 if test -n "$TOUCH"; then
11851   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
11852 $as_echo "$TOUCH" >&6; }
11853 else
11854   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11855 $as_echo "no" >&6; }
11856 fi
11857 
11858 
11859           if test "x$TOUCH" = x; then
11860             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11861           fi
11862         else
11863           # Otherwise we believe it is a complete path. Use it as it is.
11864           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TOUCH=$tool_specified" >&5
11865 $as_echo "$as_me: Will use user supplied tool TOUCH=$tool_specified" >&6;}
11866           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TOUCH" >&5
11867 $as_echo_n "checking for TOUCH... " >&6; }
11868           if test ! -x "$tool_specified"; then
11869             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11870 $as_echo "not found" >&6; }
11871             as_fn_error $? "User supplied tool TOUCH=$tool_specified does not exist or is not executable" "$LINENO" 5
11872           fi
11873           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11874 $as_echo "$tool_specified" >&6; }
11875         fi
11876       fi
11877     fi
11878 
11879   fi
11880 
11881 
11882 
11883   if test "x$TOUCH" = x; then
11884     as_fn_error $? "Could not find required tool for TOUCH" "$LINENO" 5
11885   fi
11886 
11887 
11888 
11889 
11890 
11891   # Publish this variable in the help.
11892 
11893 
11894   if [ -z "${TR+x}" ]; then
11895     # The variable is not set by user, try to locate tool using the code snippet
11896     for ac_prog in tr
11897 do
11898   # Extract the first word of "$ac_prog", so it can be a program name with args.
11899 set dummy $ac_prog; ac_word=$2
11900 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11901 $as_echo_n "checking for $ac_word... " >&6; }
11902 if ${ac_cv_path_TR+:} false; then :
11903   $as_echo_n "(cached) " >&6
11904 else
11905   case $TR in
11906   [\\/]* | ?:[\\/]*)
11907   ac_cv_path_TR="$TR" # Let the user override the test with a path.
11908   ;;
11909   *)
11910   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11911 for as_dir in $PATH
11912 do
11913   IFS=$as_save_IFS
11914   test -z "$as_dir" && as_dir=.
11915     for ac_exec_ext in '' $ac_executable_extensions; do
11916   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11917     ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
11918     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11919     break 2
11920   fi
11921 done
11922   done
11923 IFS=$as_save_IFS
11924 
11925   ;;
11926 esac
11927 fi
11928 TR=$ac_cv_path_TR
11929 if test -n "$TR"; then
11930   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
11931 $as_echo "$TR" >&6; }
11932 else
11933   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11934 $as_echo "no" >&6; }
11935 fi
11936 
11937 
11938   test -n "$TR" && break
11939 done
11940 
11941   else
11942     # The variable is set, but is it from the command line or the environment?
11943 
11944     # Try to remove the string !TR! from our list.
11945     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TR!/}
11946     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11947       # If it failed, the variable was not from the command line. Ignore it,
11948       # but warn the user (except for BASH, which is always set by the calling BASH).
11949       if test "xTR" != xBASH; then
11950         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TR from the environment. Use command line variables instead." >&5
11951 $as_echo "$as_me: WARNING: Ignoring value of TR from the environment. Use command line variables instead." >&2;}
11952       fi
11953       # Try to locate tool using the code snippet
11954       for ac_prog in tr
11955 do
11956   # Extract the first word of "$ac_prog", so it can be a program name with args.
11957 set dummy $ac_prog; ac_word=$2
11958 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11959 $as_echo_n "checking for $ac_word... " >&6; }
11960 if ${ac_cv_path_TR+:} false; then :
11961   $as_echo_n "(cached) " >&6
11962 else
11963   case $TR in
11964   [\\/]* | ?:[\\/]*)
11965   ac_cv_path_TR="$TR" # Let the user override the test with a path.
11966   ;;
11967   *)
11968   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11969 for as_dir in $PATH
11970 do
11971   IFS=$as_save_IFS
11972   test -z "$as_dir" && as_dir=.
11973     for ac_exec_ext in '' $ac_executable_extensions; do
11974   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11975     ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
11976     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11977     break 2
11978   fi
11979 done
11980   done
11981 IFS=$as_save_IFS
11982 
11983   ;;
11984 esac
11985 fi
11986 TR=$ac_cv_path_TR
11987 if test -n "$TR"; then
11988   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
11989 $as_echo "$TR" >&6; }
11990 else
11991   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11992 $as_echo "no" >&6; }
11993 fi
11994 
11995 
11996   test -n "$TR" && break
11997 done
11998 
11999     else
12000       # If it succeeded, then it was overridden by the user. We will use it
12001       # for the tool.
12002 
12003       # First remove it from the list of overridden variables, so we can test
12004       # for unknown variables in the end.
12005       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12006 
12007       # Check if we try to supply an empty value
12008       if test "x$TR" = x; then
12009         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool TR= (no value)" >&5
12010 $as_echo "$as_me: Setting user supplied tool TR= (no value)" >&6;}
12011         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TR" >&5
12012 $as_echo_n "checking for TR... " >&6; }
12013         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
12014 $as_echo "disabled" >&6; }
12015       else
12016         # Check if the provided tool contains a complete path.
12017         tool_specified="$TR"
12018         tool_basename="${tool_specified##*/}"
12019         if test "x$tool_basename" = "x$tool_specified"; then
12020           # A command without a complete path is provided, search $PATH.
12021           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TR=$tool_basename" >&5
12022 $as_echo "$as_me: Will search for user supplied tool TR=$tool_basename" >&6;}
12023           # Extract the first word of "$tool_basename", so it can be a program name with args.
12024 set dummy $tool_basename; ac_word=$2
12025 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12026 $as_echo_n "checking for $ac_word... " >&6; }
12027 if ${ac_cv_path_TR+:} false; then :
12028   $as_echo_n "(cached) " >&6
12029 else
12030   case $TR in
12031   [\\/]* | ?:[\\/]*)
12032   ac_cv_path_TR="$TR" # Let the user override the test with a path.
12033   ;;
12034   *)
12035   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12036 for as_dir in $PATH
12037 do
12038   IFS=$as_save_IFS
12039   test -z "$as_dir" && as_dir=.
12040     for ac_exec_ext in '' $ac_executable_extensions; do
12041   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12042     ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
12043     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12044     break 2
12045   fi
12046 done
12047   done
12048 IFS=$as_save_IFS
12049 
12050   ;;
12051 esac
12052 fi
12053 TR=$ac_cv_path_TR
12054 if test -n "$TR"; then
12055   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
12056 $as_echo "$TR" >&6; }
12057 else
12058   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12059 $as_echo "no" >&6; }
12060 fi
12061 
12062 
12063           if test "x$TR" = x; then
12064             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12065           fi
12066         else
12067           # Otherwise we believe it is a complete path. Use it as it is.
12068           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TR=$tool_specified" >&5
12069 $as_echo "$as_me: Will use user supplied tool TR=$tool_specified" >&6;}
12070           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TR" >&5
12071 $as_echo_n "checking for TR... " >&6; }
12072           if test ! -x "$tool_specified"; then
12073             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12074 $as_echo "not found" >&6; }
12075             as_fn_error $? "User supplied tool TR=$tool_specified does not exist or is not executable" "$LINENO" 5
12076           fi
12077           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12078 $as_echo "$tool_specified" >&6; }
12079         fi
12080       fi
12081     fi
12082 
12083   fi
12084 
12085 
12086 
12087   if test "x$TR" = x; then
12088     as_fn_error $? "Could not find required tool for TR" "$LINENO" 5
12089   fi
12090 
12091 
12092 
12093 
12094 
12095   # Publish this variable in the help.
12096 
12097 
12098   if [ -z "${UNAME+x}" ]; then
12099     # The variable is not set by user, try to locate tool using the code snippet
12100     for ac_prog in uname
12101 do
12102   # Extract the first word of "$ac_prog", so it can be a program name with args.
12103 set dummy $ac_prog; ac_word=$2
12104 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12105 $as_echo_n "checking for $ac_word... " >&6; }
12106 if ${ac_cv_path_UNAME+:} false; then :
12107   $as_echo_n "(cached) " >&6
12108 else
12109   case $UNAME in
12110   [\\/]* | ?:[\\/]*)
12111   ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
12112   ;;
12113   *)
12114   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12115 for as_dir in $PATH
12116 do
12117   IFS=$as_save_IFS
12118   test -z "$as_dir" && as_dir=.
12119     for ac_exec_ext in '' $ac_executable_extensions; do
12120   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12121     ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
12122     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12123     break 2
12124   fi
12125 done
12126   done
12127 IFS=$as_save_IFS
12128 
12129   ;;
12130 esac
12131 fi
12132 UNAME=$ac_cv_path_UNAME
12133 if test -n "$UNAME"; then
12134   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
12135 $as_echo "$UNAME" >&6; }
12136 else
12137   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12138 $as_echo "no" >&6; }
12139 fi
12140 
12141 
12142   test -n "$UNAME" && break
12143 done
12144 
12145   else
12146     # The variable is set, but is it from the command line or the environment?
12147 
12148     # Try to remove the string !UNAME! from our list.
12149     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNAME!/}
12150     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12151       # If it failed, the variable was not from the command line. Ignore it,
12152       # but warn the user (except for BASH, which is always set by the calling BASH).
12153       if test "xUNAME" != xBASH; then
12154         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNAME from the environment. Use command line variables instead." >&5
12155 $as_echo "$as_me: WARNING: Ignoring value of UNAME from the environment. Use command line variables instead." >&2;}
12156       fi
12157       # Try to locate tool using the code snippet
12158       for ac_prog in uname
12159 do
12160   # Extract the first word of "$ac_prog", so it can be a program name with args.
12161 set dummy $ac_prog; ac_word=$2
12162 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12163 $as_echo_n "checking for $ac_word... " >&6; }
12164 if ${ac_cv_path_UNAME+:} false; then :
12165   $as_echo_n "(cached) " >&6
12166 else
12167   case $UNAME in
12168   [\\/]* | ?:[\\/]*)
12169   ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
12170   ;;
12171   *)
12172   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12173 for as_dir in $PATH
12174 do
12175   IFS=$as_save_IFS
12176   test -z "$as_dir" && as_dir=.
12177     for ac_exec_ext in '' $ac_executable_extensions; do
12178   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12179     ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
12180     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12181     break 2
12182   fi
12183 done
12184   done
12185 IFS=$as_save_IFS
12186 
12187   ;;
12188 esac
12189 fi
12190 UNAME=$ac_cv_path_UNAME
12191 if test -n "$UNAME"; then
12192   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
12193 $as_echo "$UNAME" >&6; }
12194 else
12195   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12196 $as_echo "no" >&6; }
12197 fi
12198 
12199 
12200   test -n "$UNAME" && break
12201 done
12202 
12203     else
12204       # If it succeeded, then it was overridden by the user. We will use it
12205       # for the tool.
12206 
12207       # First remove it from the list of overridden variables, so we can test
12208       # for unknown variables in the end.
12209       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12210 
12211       # Check if we try to supply an empty value
12212       if test "x$UNAME" = x; then
12213         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool UNAME= (no value)" >&5
12214 $as_echo "$as_me: Setting user supplied tool UNAME= (no value)" >&6;}
12215         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNAME" >&5
12216 $as_echo_n "checking for UNAME... " >&6; }
12217         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
12218 $as_echo "disabled" >&6; }
12219       else
12220         # Check if the provided tool contains a complete path.
12221         tool_specified="$UNAME"
12222         tool_basename="${tool_specified##*/}"
12223         if test "x$tool_basename" = "x$tool_specified"; then
12224           # A command without a complete path is provided, search $PATH.
12225           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNAME=$tool_basename" >&5
12226 $as_echo "$as_me: Will search for user supplied tool UNAME=$tool_basename" >&6;}
12227           # Extract the first word of "$tool_basename", so it can be a program name with args.
12228 set dummy $tool_basename; ac_word=$2
12229 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12230 $as_echo_n "checking for $ac_word... " >&6; }
12231 if ${ac_cv_path_UNAME+:} false; then :
12232   $as_echo_n "(cached) " >&6
12233 else
12234   case $UNAME in
12235   [\\/]* | ?:[\\/]*)
12236   ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
12237   ;;
12238   *)
12239   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12240 for as_dir in $PATH
12241 do
12242   IFS=$as_save_IFS
12243   test -z "$as_dir" && as_dir=.
12244     for ac_exec_ext in '' $ac_executable_extensions; do
12245   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12246     ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
12247     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12248     break 2
12249   fi
12250 done
12251   done
12252 IFS=$as_save_IFS
12253 
12254   ;;
12255 esac
12256 fi
12257 UNAME=$ac_cv_path_UNAME
12258 if test -n "$UNAME"; then
12259   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
12260 $as_echo "$UNAME" >&6; }
12261 else
12262   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12263 $as_echo "no" >&6; }
12264 fi
12265 
12266 
12267           if test "x$UNAME" = x; then
12268             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12269           fi
12270         else
12271           # Otherwise we believe it is a complete path. Use it as it is.
12272           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNAME=$tool_specified" >&5
12273 $as_echo "$as_me: Will use user supplied tool UNAME=$tool_specified" >&6;}
12274           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNAME" >&5
12275 $as_echo_n "checking for UNAME... " >&6; }
12276           if test ! -x "$tool_specified"; then
12277             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12278 $as_echo "not found" >&6; }
12279             as_fn_error $? "User supplied tool UNAME=$tool_specified does not exist or is not executable" "$LINENO" 5
12280           fi
12281           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12282 $as_echo "$tool_specified" >&6; }
12283         fi
12284       fi
12285     fi
12286 
12287   fi
12288 
12289 
12290 
12291   if test "x$UNAME" = x; then
12292     as_fn_error $? "Could not find required tool for UNAME" "$LINENO" 5
12293   fi
12294 
12295 
12296 
12297 
12298 
12299   # Publish this variable in the help.
12300 
12301 
12302   if [ -z "${UNIQ+x}" ]; then
12303     # The variable is not set by user, try to locate tool using the code snippet
12304     for ac_prog in uniq
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_path_UNIQ+:} false; then :
12311   $as_echo_n "(cached) " >&6
12312 else
12313   case $UNIQ in
12314   [\\/]* | ?:[\\/]*)
12315   ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
12316   ;;
12317   *)
12318   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12319 for as_dir in $PATH
12320 do
12321   IFS=$as_save_IFS
12322   test -z "$as_dir" && as_dir=.
12323     for ac_exec_ext in '' $ac_executable_extensions; do
12324   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12325     ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
12326     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12327     break 2
12328   fi
12329 done
12330   done
12331 IFS=$as_save_IFS
12332 
12333   ;;
12334 esac
12335 fi
12336 UNIQ=$ac_cv_path_UNIQ
12337 if test -n "$UNIQ"; then
12338   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
12339 $as_echo "$UNIQ" >&6; }
12340 else
12341   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12342 $as_echo "no" >&6; }
12343 fi
12344 
12345 
12346   test -n "$UNIQ" && break
12347 done
12348 
12349   else
12350     # The variable is set, but is it from the command line or the environment?
12351 
12352     # Try to remove the string !UNIQ! from our list.
12353     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNIQ!/}
12354     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12355       # If it failed, the variable was not from the command line. Ignore it,
12356       # but warn the user (except for BASH, which is always set by the calling BASH).
12357       if test "xUNIQ" != xBASH; then
12358         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNIQ from the environment. Use command line variables instead." >&5
12359 $as_echo "$as_me: WARNING: Ignoring value of UNIQ from the environment. Use command line variables instead." >&2;}
12360       fi
12361       # Try to locate tool using the code snippet
12362       for ac_prog in uniq
12363 do
12364   # Extract the first word of "$ac_prog", so it can be a program name with args.
12365 set dummy $ac_prog; ac_word=$2
12366 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12367 $as_echo_n "checking for $ac_word... " >&6; }
12368 if ${ac_cv_path_UNIQ+:} false; then :
12369   $as_echo_n "(cached) " >&6
12370 else
12371   case $UNIQ in
12372   [\\/]* | ?:[\\/]*)
12373   ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
12374   ;;
12375   *)
12376   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12377 for as_dir in $PATH
12378 do
12379   IFS=$as_save_IFS
12380   test -z "$as_dir" && as_dir=.
12381     for ac_exec_ext in '' $ac_executable_extensions; do
12382   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12383     ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
12384     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12385     break 2
12386   fi
12387 done
12388   done
12389 IFS=$as_save_IFS
12390 
12391   ;;
12392 esac
12393 fi
12394 UNIQ=$ac_cv_path_UNIQ
12395 if test -n "$UNIQ"; then
12396   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
12397 $as_echo "$UNIQ" >&6; }
12398 else
12399   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12400 $as_echo "no" >&6; }
12401 fi
12402 
12403 
12404   test -n "$UNIQ" && break
12405 done
12406 
12407     else
12408       # If it succeeded, then it was overridden by the user. We will use it
12409       # for the tool.
12410 
12411       # First remove it from the list of overridden variables, so we can test
12412       # for unknown variables in the end.
12413       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12414 
12415       # Check if we try to supply an empty value
12416       if test "x$UNIQ" = x; then
12417         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool UNIQ= (no value)" >&5
12418 $as_echo "$as_me: Setting user supplied tool UNIQ= (no value)" >&6;}
12419         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNIQ" >&5
12420 $as_echo_n "checking for UNIQ... " >&6; }
12421         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
12422 $as_echo "disabled" >&6; }
12423       else
12424         # Check if the provided tool contains a complete path.
12425         tool_specified="$UNIQ"
12426         tool_basename="${tool_specified##*/}"
12427         if test "x$tool_basename" = "x$tool_specified"; then
12428           # A command without a complete path is provided, search $PATH.
12429           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNIQ=$tool_basename" >&5
12430 $as_echo "$as_me: Will search for user supplied tool UNIQ=$tool_basename" >&6;}
12431           # Extract the first word of "$tool_basename", so it can be a program name with args.
12432 set dummy $tool_basename; ac_word=$2
12433 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12434 $as_echo_n "checking for $ac_word... " >&6; }
12435 if ${ac_cv_path_UNIQ+:} false; then :
12436   $as_echo_n "(cached) " >&6
12437 else
12438   case $UNIQ in
12439   [\\/]* | ?:[\\/]*)
12440   ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
12441   ;;
12442   *)
12443   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12444 for as_dir in $PATH
12445 do
12446   IFS=$as_save_IFS
12447   test -z "$as_dir" && as_dir=.
12448     for ac_exec_ext in '' $ac_executable_extensions; do
12449   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12450     ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
12451     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12452     break 2
12453   fi
12454 done
12455   done
12456 IFS=$as_save_IFS
12457 
12458   ;;
12459 esac
12460 fi
12461 UNIQ=$ac_cv_path_UNIQ
12462 if test -n "$UNIQ"; then
12463   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
12464 $as_echo "$UNIQ" >&6; }
12465 else
12466   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12467 $as_echo "no" >&6; }
12468 fi
12469 
12470 
12471           if test "x$UNIQ" = x; then
12472             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12473           fi
12474         else
12475           # Otherwise we believe it is a complete path. Use it as it is.
12476           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNIQ=$tool_specified" >&5
12477 $as_echo "$as_me: Will use user supplied tool UNIQ=$tool_specified" >&6;}
12478           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNIQ" >&5
12479 $as_echo_n "checking for UNIQ... " >&6; }
12480           if test ! -x "$tool_specified"; then
12481             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12482 $as_echo "not found" >&6; }
12483             as_fn_error $? "User supplied tool UNIQ=$tool_specified does not exist or is not executable" "$LINENO" 5
12484           fi
12485           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12486 $as_echo "$tool_specified" >&6; }
12487         fi
12488       fi
12489     fi
12490 
12491   fi
12492 
12493 
12494 
12495   if test "x$UNIQ" = x; then
12496     as_fn_error $? "Could not find required tool for UNIQ" "$LINENO" 5
12497   fi
12498 
12499 
12500 
12501 
12502 
12503   # Publish this variable in the help.
12504 
12505 
12506   if [ -z "${WC+x}" ]; then
12507     # The variable is not set by user, try to locate tool using the code snippet
12508     for ac_prog in wc
12509 do
12510   # Extract the first word of "$ac_prog", so it can be a program name with args.
12511 set dummy $ac_prog; ac_word=$2
12512 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12513 $as_echo_n "checking for $ac_word... " >&6; }
12514 if ${ac_cv_path_WC+:} false; then :
12515   $as_echo_n "(cached) " >&6
12516 else
12517   case $WC in
12518   [\\/]* | ?:[\\/]*)
12519   ac_cv_path_WC="$WC" # Let the user override the test with a path.
12520   ;;
12521   *)
12522   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12523 for as_dir in $PATH
12524 do
12525   IFS=$as_save_IFS
12526   test -z "$as_dir" && as_dir=.
12527     for ac_exec_ext in '' $ac_executable_extensions; do
12528   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12529     ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
12530     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12531     break 2
12532   fi
12533 done
12534   done
12535 IFS=$as_save_IFS
12536 
12537   ;;
12538 esac
12539 fi
12540 WC=$ac_cv_path_WC
12541 if test -n "$WC"; then
12542   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
12543 $as_echo "$WC" >&6; }
12544 else
12545   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12546 $as_echo "no" >&6; }
12547 fi
12548 
12549 
12550   test -n "$WC" && break
12551 done
12552 
12553   else
12554     # The variable is set, but is it from the command line or the environment?
12555 
12556     # Try to remove the string !WC! from our list.
12557     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!WC!/}
12558     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12559       # If it failed, the variable was not from the command line. Ignore it,
12560       # but warn the user (except for BASH, which is always set by the calling BASH).
12561       if test "xWC" != xBASH; then
12562         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of WC from the environment. Use command line variables instead." >&5
12563 $as_echo "$as_me: WARNING: Ignoring value of WC from the environment. Use command line variables instead." >&2;}
12564       fi
12565       # Try to locate tool using the code snippet
12566       for ac_prog in wc
12567 do
12568   # Extract the first word of "$ac_prog", so it can be a program name with args.
12569 set dummy $ac_prog; ac_word=$2
12570 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12571 $as_echo_n "checking for $ac_word... " >&6; }
12572 if ${ac_cv_path_WC+:} false; then :
12573   $as_echo_n "(cached) " >&6
12574 else
12575   case $WC in
12576   [\\/]* | ?:[\\/]*)
12577   ac_cv_path_WC="$WC" # Let the user override the test with a path.
12578   ;;
12579   *)
12580   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12581 for as_dir in $PATH
12582 do
12583   IFS=$as_save_IFS
12584   test -z "$as_dir" && as_dir=.
12585     for ac_exec_ext in '' $ac_executable_extensions; do
12586   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12587     ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
12588     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12589     break 2
12590   fi
12591 done
12592   done
12593 IFS=$as_save_IFS
12594 
12595   ;;
12596 esac
12597 fi
12598 WC=$ac_cv_path_WC
12599 if test -n "$WC"; then
12600   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
12601 $as_echo "$WC" >&6; }
12602 else
12603   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12604 $as_echo "no" >&6; }
12605 fi
12606 
12607 
12608   test -n "$WC" && break
12609 done
12610 
12611     else
12612       # If it succeeded, then it was overridden by the user. We will use it
12613       # for the tool.
12614 
12615       # First remove it from the list of overridden variables, so we can test
12616       # for unknown variables in the end.
12617       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12618 
12619       # Check if we try to supply an empty value
12620       if test "x$WC" = x; then
12621         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool WC= (no value)" >&5
12622 $as_echo "$as_me: Setting user supplied tool WC= (no value)" >&6;}
12623         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WC" >&5
12624 $as_echo_n "checking for WC... " >&6; }
12625         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
12626 $as_echo "disabled" >&6; }
12627       else
12628         # Check if the provided tool contains a complete path.
12629         tool_specified="$WC"
12630         tool_basename="${tool_specified##*/}"
12631         if test "x$tool_basename" = "x$tool_specified"; then
12632           # A command without a complete path is provided, search $PATH.
12633           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool WC=$tool_basename" >&5
12634 $as_echo "$as_me: Will search for user supplied tool WC=$tool_basename" >&6;}
12635           # Extract the first word of "$tool_basename", so it can be a program name with args.
12636 set dummy $tool_basename; ac_word=$2
12637 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12638 $as_echo_n "checking for $ac_word... " >&6; }
12639 if ${ac_cv_path_WC+:} false; then :
12640   $as_echo_n "(cached) " >&6
12641 else
12642   case $WC in
12643   [\\/]* | ?:[\\/]*)
12644   ac_cv_path_WC="$WC" # Let the user override the test with a path.
12645   ;;
12646   *)
12647   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12648 for as_dir in $PATH
12649 do
12650   IFS=$as_save_IFS
12651   test -z "$as_dir" && as_dir=.
12652     for ac_exec_ext in '' $ac_executable_extensions; do
12653   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12654     ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
12655     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12656     break 2
12657   fi
12658 done
12659   done
12660 IFS=$as_save_IFS
12661 
12662   ;;
12663 esac
12664 fi
12665 WC=$ac_cv_path_WC
12666 if test -n "$WC"; then
12667   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
12668 $as_echo "$WC" >&6; }
12669 else
12670   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12671 $as_echo "no" >&6; }
12672 fi
12673 
12674 
12675           if test "x$WC" = x; then
12676             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12677           fi
12678         else
12679           # Otherwise we believe it is a complete path. Use it as it is.
12680           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool WC=$tool_specified" >&5
12681 $as_echo "$as_me: Will use user supplied tool WC=$tool_specified" >&6;}
12682           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WC" >&5
12683 $as_echo_n "checking for WC... " >&6; }
12684           if test ! -x "$tool_specified"; then
12685             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12686 $as_echo "not found" >&6; }
12687             as_fn_error $? "User supplied tool WC=$tool_specified does not exist or is not executable" "$LINENO" 5
12688           fi
12689           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12690 $as_echo "$tool_specified" >&6; }
12691         fi
12692       fi
12693     fi
12694 
12695   fi
12696 
12697 
12698 
12699   if test "x$WC" = x; then
12700     as_fn_error $? "Could not find required tool for WC" "$LINENO" 5
12701   fi
12702 
12703 
12704 
12705 
12706 
12707   # Publish this variable in the help.
12708 
12709 
12710   if [ -z "${WHICH+x}" ]; then
12711     # The variable is not set by user, try to locate tool using the code snippet
12712     for ac_prog in which
12713 do
12714   # Extract the first word of "$ac_prog", so it can be a program name with args.
12715 set dummy $ac_prog; ac_word=$2
12716 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12717 $as_echo_n "checking for $ac_word... " >&6; }
12718 if ${ac_cv_path_WHICH+:} false; then :
12719   $as_echo_n "(cached) " >&6
12720 else
12721   case $WHICH in
12722   [\\/]* | ?:[\\/]*)
12723   ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
12724   ;;
12725   *)
12726   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12727 for as_dir in $PATH
12728 do
12729   IFS=$as_save_IFS
12730   test -z "$as_dir" && as_dir=.
12731     for ac_exec_ext in '' $ac_executable_extensions; do
12732   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12733     ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
12734     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12735     break 2
12736   fi
12737 done
12738   done
12739 IFS=$as_save_IFS
12740 
12741   ;;
12742 esac
12743 fi
12744 WHICH=$ac_cv_path_WHICH
12745 if test -n "$WHICH"; then
12746   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
12747 $as_echo "$WHICH" >&6; }
12748 else
12749   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12750 $as_echo "no" >&6; }
12751 fi
12752 
12753 
12754   test -n "$WHICH" && break
12755 done
12756 
12757   else
12758     # The variable is set, but is it from the command line or the environment?
12759 
12760     # Try to remove the string !WHICH! from our list.
12761     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!WHICH!/}
12762     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12763       # If it failed, the variable was not from the command line. Ignore it,
12764       # but warn the user (except for BASH, which is always set by the calling BASH).
12765       if test "xWHICH" != xBASH; then
12766         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of WHICH from the environment. Use command line variables instead." >&5
12767 $as_echo "$as_me: WARNING: Ignoring value of WHICH from the environment. Use command line variables instead." >&2;}
12768       fi
12769       # Try to locate tool using the code snippet
12770       for ac_prog in which
12771 do
12772   # Extract the first word of "$ac_prog", so it can be a program name with args.
12773 set dummy $ac_prog; ac_word=$2
12774 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12775 $as_echo_n "checking for $ac_word... " >&6; }
12776 if ${ac_cv_path_WHICH+:} false; then :
12777   $as_echo_n "(cached) " >&6
12778 else
12779   case $WHICH in
12780   [\\/]* | ?:[\\/]*)
12781   ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
12782   ;;
12783   *)
12784   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12785 for as_dir in $PATH
12786 do
12787   IFS=$as_save_IFS
12788   test -z "$as_dir" && as_dir=.
12789     for ac_exec_ext in '' $ac_executable_extensions; do
12790   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12791     ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
12792     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12793     break 2
12794   fi
12795 done
12796   done
12797 IFS=$as_save_IFS
12798 
12799   ;;
12800 esac
12801 fi
12802 WHICH=$ac_cv_path_WHICH
12803 if test -n "$WHICH"; then
12804   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
12805 $as_echo "$WHICH" >&6; }
12806 else
12807   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12808 $as_echo "no" >&6; }
12809 fi
12810 
12811 
12812   test -n "$WHICH" && break
12813 done
12814 
12815     else
12816       # If it succeeded, then it was overridden by the user. We will use it
12817       # for the tool.
12818 
12819       # First remove it from the list of overridden variables, so we can test
12820       # for unknown variables in the end.
12821       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12822 
12823       # Check if we try to supply an empty value
12824       if test "x$WHICH" = x; then
12825         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool WHICH= (no value)" >&5
12826 $as_echo "$as_me: Setting user supplied tool WHICH= (no value)" >&6;}
12827         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WHICH" >&5
12828 $as_echo_n "checking for WHICH... " >&6; }
12829         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
12830 $as_echo "disabled" >&6; }
12831       else
12832         # Check if the provided tool contains a complete path.
12833         tool_specified="$WHICH"
12834         tool_basename="${tool_specified##*/}"
12835         if test "x$tool_basename" = "x$tool_specified"; then
12836           # A command without a complete path is provided, search $PATH.
12837           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool WHICH=$tool_basename" >&5
12838 $as_echo "$as_me: Will search for user supplied tool WHICH=$tool_basename" >&6;}
12839           # Extract the first word of "$tool_basename", so it can be a program name with args.
12840 set dummy $tool_basename; ac_word=$2
12841 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12842 $as_echo_n "checking for $ac_word... " >&6; }
12843 if ${ac_cv_path_WHICH+:} false; then :
12844   $as_echo_n "(cached) " >&6
12845 else
12846   case $WHICH in
12847   [\\/]* | ?:[\\/]*)
12848   ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
12849   ;;
12850   *)
12851   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12852 for as_dir in $PATH
12853 do
12854   IFS=$as_save_IFS
12855   test -z "$as_dir" && as_dir=.
12856     for ac_exec_ext in '' $ac_executable_extensions; do
12857   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12858     ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
12859     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12860     break 2
12861   fi
12862 done
12863   done
12864 IFS=$as_save_IFS
12865 
12866   ;;
12867 esac
12868 fi
12869 WHICH=$ac_cv_path_WHICH
12870 if test -n "$WHICH"; then
12871   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
12872 $as_echo "$WHICH" >&6; }
12873 else
12874   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12875 $as_echo "no" >&6; }
12876 fi
12877 
12878 
12879           if test "x$WHICH" = x; then
12880             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12881           fi
12882         else
12883           # Otherwise we believe it is a complete path. Use it as it is.
12884           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool WHICH=$tool_specified" >&5
12885 $as_echo "$as_me: Will use user supplied tool WHICH=$tool_specified" >&6;}
12886           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WHICH" >&5
12887 $as_echo_n "checking for WHICH... " >&6; }
12888           if test ! -x "$tool_specified"; then
12889             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12890 $as_echo "not found" >&6; }
12891             as_fn_error $? "User supplied tool WHICH=$tool_specified does not exist or is not executable" "$LINENO" 5
12892           fi
12893           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12894 $as_echo "$tool_specified" >&6; }
12895         fi
12896       fi
12897     fi
12898 
12899   fi
12900 
12901 
12902 
12903   if test "x$WHICH" = x; then
12904     as_fn_error $? "Could not find required tool for WHICH" "$LINENO" 5
12905   fi
12906 
12907 
12908 
12909 
12910 
12911   # Publish this variable in the help.
12912 
12913 
12914   if [ -z "${XARGS+x}" ]; then
12915     # The variable is not set by user, try to locate tool using the code snippet
12916     for ac_prog in xargs
12917 do
12918   # Extract the first word of "$ac_prog", so it can be a program name with args.
12919 set dummy $ac_prog; ac_word=$2
12920 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12921 $as_echo_n "checking for $ac_word... " >&6; }
12922 if ${ac_cv_path_XARGS+:} false; then :
12923   $as_echo_n "(cached) " >&6
12924 else
12925   case $XARGS in
12926   [\\/]* | ?:[\\/]*)
12927   ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
12928   ;;
12929   *)
12930   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12931 for as_dir in $PATH
12932 do
12933   IFS=$as_save_IFS
12934   test -z "$as_dir" && as_dir=.
12935     for ac_exec_ext in '' $ac_executable_extensions; do
12936   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12937     ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
12938     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12939     break 2
12940   fi
12941 done
12942   done
12943 IFS=$as_save_IFS
12944 
12945   ;;
12946 esac
12947 fi
12948 XARGS=$ac_cv_path_XARGS
12949 if test -n "$XARGS"; then
12950   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
12951 $as_echo "$XARGS" >&6; }
12952 else
12953   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12954 $as_echo "no" >&6; }
12955 fi
12956 
12957 
12958   test -n "$XARGS" && break
12959 done
12960 
12961   else
12962     # The variable is set, but is it from the command line or the environment?
12963 
12964     # Try to remove the string !XARGS! from our list.
12965     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!XARGS!/}
12966     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12967       # If it failed, the variable was not from the command line. Ignore it,
12968       # but warn the user (except for BASH, which is always set by the calling BASH).
12969       if test "xXARGS" != xBASH; then
12970         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of XARGS from the environment. Use command line variables instead." >&5
12971 $as_echo "$as_me: WARNING: Ignoring value of XARGS from the environment. Use command line variables instead." >&2;}
12972       fi
12973       # Try to locate tool using the code snippet
12974       for ac_prog in xargs
12975 do
12976   # Extract the first word of "$ac_prog", so it can be a program name with args.
12977 set dummy $ac_prog; ac_word=$2
12978 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12979 $as_echo_n "checking for $ac_word... " >&6; }
12980 if ${ac_cv_path_XARGS+:} false; then :
12981   $as_echo_n "(cached) " >&6
12982 else
12983   case $XARGS in
12984   [\\/]* | ?:[\\/]*)
12985   ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
12986   ;;
12987   *)
12988   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12989 for as_dir in $PATH
12990 do
12991   IFS=$as_save_IFS
12992   test -z "$as_dir" && as_dir=.
12993     for ac_exec_ext in '' $ac_executable_extensions; do
12994   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12995     ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
12996     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12997     break 2
12998   fi
12999 done
13000   done
13001 IFS=$as_save_IFS
13002 
13003   ;;
13004 esac
13005 fi
13006 XARGS=$ac_cv_path_XARGS
13007 if test -n "$XARGS"; then
13008   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
13009 $as_echo "$XARGS" >&6; }
13010 else
13011   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13012 $as_echo "no" >&6; }
13013 fi
13014 
13015 
13016   test -n "$XARGS" && break
13017 done
13018 
13019     else
13020       # If it succeeded, then it was overridden by the user. We will use it
13021       # for the tool.
13022 
13023       # First remove it from the list of overridden variables, so we can test
13024       # for unknown variables in the end.
13025       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13026 
13027       # Check if we try to supply an empty value
13028       if test "x$XARGS" = x; then
13029         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool XARGS= (no value)" >&5
13030 $as_echo "$as_me: Setting user supplied tool XARGS= (no value)" >&6;}
13031         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XARGS" >&5
13032 $as_echo_n "checking for XARGS... " >&6; }
13033         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
13034 $as_echo "disabled" >&6; }
13035       else
13036         # Check if the provided tool contains a complete path.
13037         tool_specified="$XARGS"
13038         tool_basename="${tool_specified##*/}"
13039         if test "x$tool_basename" = "x$tool_specified"; then
13040           # A command without a complete path is provided, search $PATH.
13041           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool XARGS=$tool_basename" >&5
13042 $as_echo "$as_me: Will search for user supplied tool XARGS=$tool_basename" >&6;}
13043           # Extract the first word of "$tool_basename", so it can be a program name with args.
13044 set dummy $tool_basename; ac_word=$2
13045 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13046 $as_echo_n "checking for $ac_word... " >&6; }
13047 if ${ac_cv_path_XARGS+:} false; then :
13048   $as_echo_n "(cached) " >&6
13049 else
13050   case $XARGS in
13051   [\\/]* | ?:[\\/]*)
13052   ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
13053   ;;
13054   *)
13055   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13056 for as_dir in $PATH
13057 do
13058   IFS=$as_save_IFS
13059   test -z "$as_dir" && as_dir=.
13060     for ac_exec_ext in '' $ac_executable_extensions; do
13061   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13062     ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
13063     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13064     break 2
13065   fi
13066 done
13067   done
13068 IFS=$as_save_IFS
13069 
13070   ;;
13071 esac
13072 fi
13073 XARGS=$ac_cv_path_XARGS
13074 if test -n "$XARGS"; then
13075   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
13076 $as_echo "$XARGS" >&6; }
13077 else
13078   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13079 $as_echo "no" >&6; }
13080 fi
13081 
13082 
13083           if test "x$XARGS" = x; then
13084             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13085           fi
13086         else
13087           # Otherwise we believe it is a complete path. Use it as it is.
13088           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool XARGS=$tool_specified" >&5
13089 $as_echo "$as_me: Will use user supplied tool XARGS=$tool_specified" >&6;}
13090           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XARGS" >&5
13091 $as_echo_n "checking for XARGS... " >&6; }
13092           if test ! -x "$tool_specified"; then
13093             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13094 $as_echo "not found" >&6; }
13095             as_fn_error $? "User supplied tool XARGS=$tool_specified does not exist or is not executable" "$LINENO" 5
13096           fi
13097           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13098 $as_echo "$tool_specified" >&6; }
13099         fi
13100       fi
13101     fi
13102 
13103   fi
13104 
13105 
13106 
13107   if test "x$XARGS" = x; then
13108     as_fn_error $? "Could not find required tool for XARGS" "$LINENO" 5
13109   fi
13110 
13111 
13112 
13113   # Then required tools that require some special treatment.
13114 
13115 
13116   # Publish this variable in the help.
13117 
13118 
13119   if [ -z "${AWK+x}" ]; then
13120     # The variable is not set by user, try to locate tool using the code snippet
13121     for ac_prog in gawk mawk nawk awk
13122 do
13123   # Extract the first word of "$ac_prog", so it can be a program name with args.
13124 set dummy $ac_prog; ac_word=$2
13125 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13126 $as_echo_n "checking for $ac_word... " >&6; }
13127 if ${ac_cv_prog_AWK+:} false; then :
13128   $as_echo_n "(cached) " >&6
13129 else
13130   if test -n "$AWK"; then
13131   ac_cv_prog_AWK="$AWK" # Let the user override the test.
13132 else
13133 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13134 for as_dir in $PATH
13135 do
13136   IFS=$as_save_IFS
13137   test -z "$as_dir" && as_dir=.
13138     for ac_exec_ext in '' $ac_executable_extensions; do
13139   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13140     ac_cv_prog_AWK="$ac_prog"
13141     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13142     break 2
13143   fi
13144 done
13145   done
13146 IFS=$as_save_IFS
13147 
13148 fi
13149 fi
13150 AWK=$ac_cv_prog_AWK
13151 if test -n "$AWK"; then
13152   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
13153 $as_echo "$AWK" >&6; }
13154 else
13155   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13156 $as_echo "no" >&6; }
13157 fi
13158 
13159 
13160   test -n "$AWK" && break
13161 done
13162 
13163   else
13164     # The variable is set, but is it from the command line or the environment?
13165 
13166     # Try to remove the string !AWK! from our list.
13167     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!AWK!/}
13168     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
13169       # If it failed, the variable was not from the command line. Ignore it,
13170       # but warn the user (except for BASH, which is always set by the calling BASH).
13171       if test "xAWK" != xBASH; then
13172         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of AWK from the environment. Use command line variables instead." >&5
13173 $as_echo "$as_me: WARNING: Ignoring value of AWK from the environment. Use command line variables instead." >&2;}
13174       fi
13175       # Try to locate tool using the code snippet
13176       for ac_prog in gawk mawk nawk awk
13177 do
13178   # Extract the first word of "$ac_prog", so it can be a program name with args.
13179 set dummy $ac_prog; ac_word=$2
13180 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13181 $as_echo_n "checking for $ac_word... " >&6; }
13182 if ${ac_cv_prog_AWK+:} false; then :
13183   $as_echo_n "(cached) " >&6
13184 else
13185   if test -n "$AWK"; then
13186   ac_cv_prog_AWK="$AWK" # Let the user override the test.
13187 else
13188 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13189 for as_dir in $PATH
13190 do
13191   IFS=$as_save_IFS
13192   test -z "$as_dir" && as_dir=.
13193     for ac_exec_ext in '' $ac_executable_extensions; do
13194   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13195     ac_cv_prog_AWK="$ac_prog"
13196     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13197     break 2
13198   fi
13199 done
13200   done
13201 IFS=$as_save_IFS
13202 
13203 fi
13204 fi
13205 AWK=$ac_cv_prog_AWK
13206 if test -n "$AWK"; then
13207   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
13208 $as_echo "$AWK" >&6; }
13209 else
13210   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13211 $as_echo "no" >&6; }
13212 fi
13213 
13214 
13215   test -n "$AWK" && break
13216 done
13217 
13218     else
13219       # If it succeeded, then it was overridden by the user. We will use it
13220       # for the tool.
13221 
13222       # First remove it from the list of overridden variables, so we can test
13223       # for unknown variables in the end.
13224       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13225 
13226       # Check if we try to supply an empty value
13227       if test "x$AWK" = x; then
13228         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool AWK= (no value)" >&5
13229 $as_echo "$as_me: Setting user supplied tool AWK= (no value)" >&6;}
13230         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for AWK" >&5
13231 $as_echo_n "checking for AWK... " >&6; }
13232         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
13233 $as_echo "disabled" >&6; }
13234       else
13235         # Check if the provided tool contains a complete path.
13236         tool_specified="$AWK"
13237         tool_basename="${tool_specified##*/}"
13238         if test "x$tool_basename" = "x$tool_specified"; then
13239           # A command without a complete path is provided, search $PATH.
13240           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool AWK=$tool_basename" >&5
13241 $as_echo "$as_me: Will search for user supplied tool AWK=$tool_basename" >&6;}
13242           # Extract the first word of "$tool_basename", so it can be a program name with args.
13243 set dummy $tool_basename; ac_word=$2
13244 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13245 $as_echo_n "checking for $ac_word... " >&6; }
13246 if ${ac_cv_path_AWK+:} false; then :
13247   $as_echo_n "(cached) " >&6
13248 else
13249   case $AWK in
13250   [\\/]* | ?:[\\/]*)
13251   ac_cv_path_AWK="$AWK" # Let the user override the test with a path.
13252   ;;
13253   *)
13254   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13255 for as_dir in $PATH
13256 do
13257   IFS=$as_save_IFS
13258   test -z "$as_dir" && as_dir=.
13259     for ac_exec_ext in '' $ac_executable_extensions; do
13260   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13261     ac_cv_path_AWK="$as_dir/$ac_word$ac_exec_ext"
13262     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13263     break 2
13264   fi
13265 done
13266   done
13267 IFS=$as_save_IFS
13268 
13269   ;;
13270 esac
13271 fi
13272 AWK=$ac_cv_path_AWK
13273 if test -n "$AWK"; then
13274   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
13275 $as_echo "$AWK" >&6; }
13276 else
13277   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13278 $as_echo "no" >&6; }
13279 fi
13280 
13281 
13282           if test "x$AWK" = x; then
13283             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13284           fi
13285         else
13286           # Otherwise we believe it is a complete path. Use it as it is.
13287           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool AWK=$tool_specified" >&5
13288 $as_echo "$as_me: Will use user supplied tool AWK=$tool_specified" >&6;}
13289           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for AWK" >&5
13290 $as_echo_n "checking for AWK... " >&6; }
13291           if test ! -x "$tool_specified"; then
13292             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13293 $as_echo "not found" >&6; }
13294             as_fn_error $? "User supplied tool AWK=$tool_specified does not exist or is not executable" "$LINENO" 5
13295           fi
13296           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13297 $as_echo "$tool_specified" >&6; }
13298         fi
13299       fi
13300     fi
13301 
13302   fi
13303 
13304 
13305   if test "x$AWK" = x; then
13306     as_fn_error $? "Could not find required tool for AWK" "$LINENO" 5
13307   fi
13308 
13309 
13310 
13311 
13312   # Publish this variable in the help.
13313 
13314 
13315   if [ -z "${GREP+x}" ]; then
13316     # The variable is not set by user, try to locate tool using the code snippet
13317     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
13318 $as_echo_n "checking for grep that handles long lines and -e... " >&6; }
13319 if ${ac_cv_path_GREP+:} false; then :
13320   $as_echo_n "(cached) " >&6
13321 else
13322   if test -z "$GREP"; then
13323   ac_path_GREP_found=false
13324   # Loop through the user's path and test for each of PROGNAME-LIST
13325   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13326 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
13327 do
13328   IFS=$as_save_IFS
13329   test -z "$as_dir" && as_dir=.
13330     for ac_prog in grep ggrep; do
13331     for ac_exec_ext in '' $ac_executable_extensions; do
13332       ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
13333       as_fn_executable_p "$ac_path_GREP" || continue
13334 # Check for GNU ac_path_GREP and select it if it is found.
13335   # Check for GNU $ac_path_GREP
13336 case `"$ac_path_GREP" --version 2>&1` in
13337 *GNU*)
13338   ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
13339 *)
13340   ac_count=0
13341   $as_echo_n 0123456789 >"conftest.in"
13342   while :
13343   do
13344     cat "conftest.in" "conftest.in" >"conftest.tmp"
13345     mv "conftest.tmp" "conftest.in"
13346     cp "conftest.in" "conftest.nl"
13347     $as_echo 'GREP' >> "conftest.nl"
13348     "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
13349     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
13350     as_fn_arith $ac_count + 1 && ac_count=$as_val
13351     if test $ac_count -gt ${ac_path_GREP_max-0}; then
13352       # Best one so far, save it but keep looking for a better one
13353       ac_cv_path_GREP="$ac_path_GREP"
13354       ac_path_GREP_max=$ac_count
13355     fi
13356     # 10*(2^10) chars as input seems more than enough
13357     test $ac_count -gt 10 && break
13358   done
13359   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
13360 esac
13361 
13362       $ac_path_GREP_found && break 3
13363     done
13364   done
13365   done
13366 IFS=$as_save_IFS
13367   if test -z "$ac_cv_path_GREP"; then
13368     as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
13369   fi
13370 else
13371   ac_cv_path_GREP=$GREP
13372 fi
13373 
13374 fi
13375 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
13376 $as_echo "$ac_cv_path_GREP" >&6; }
13377  GREP="$ac_cv_path_GREP"
13378 
13379 
13380   else
13381     # The variable is set, but is it from the command line or the environment?
13382 
13383     # Try to remove the string !GREP! from our list.
13384     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!GREP!/}
13385     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
13386       # If it failed, the variable was not from the command line. Ignore it,
13387       # but warn the user (except for BASH, which is always set by the calling BASH).
13388       if test "xGREP" != xBASH; then
13389         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of GREP from the environment. Use command line variables instead." >&5
13390 $as_echo "$as_me: WARNING: Ignoring value of GREP from the environment. Use command line variables instead." >&2;}
13391       fi
13392       # Try to locate tool using the code snippet
13393       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
13394 $as_echo_n "checking for grep that handles long lines and -e... " >&6; }
13395 if ${ac_cv_path_GREP+:} false; then :
13396   $as_echo_n "(cached) " >&6
13397 else
13398   if test -z "$GREP"; then
13399   ac_path_GREP_found=false
13400   # Loop through the user's path and test for each of PROGNAME-LIST
13401   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13402 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
13403 do
13404   IFS=$as_save_IFS
13405   test -z "$as_dir" && as_dir=.
13406     for ac_prog in grep ggrep; do
13407     for ac_exec_ext in '' $ac_executable_extensions; do
13408       ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
13409       as_fn_executable_p "$ac_path_GREP" || continue
13410 # Check for GNU ac_path_GREP and select it if it is found.
13411   # Check for GNU $ac_path_GREP
13412 case `"$ac_path_GREP" --version 2>&1` in
13413 *GNU*)
13414   ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
13415 *)
13416   ac_count=0
13417   $as_echo_n 0123456789 >"conftest.in"
13418   while :
13419   do
13420     cat "conftest.in" "conftest.in" >"conftest.tmp"
13421     mv "conftest.tmp" "conftest.in"
13422     cp "conftest.in" "conftest.nl"
13423     $as_echo 'GREP' >> "conftest.nl"
13424     "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
13425     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
13426     as_fn_arith $ac_count + 1 && ac_count=$as_val
13427     if test $ac_count -gt ${ac_path_GREP_max-0}; then
13428       # Best one so far, save it but keep looking for a better one
13429       ac_cv_path_GREP="$ac_path_GREP"
13430       ac_path_GREP_max=$ac_count
13431     fi
13432     # 10*(2^10) chars as input seems more than enough
13433     test $ac_count -gt 10 && break
13434   done
13435   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
13436 esac
13437 
13438       $ac_path_GREP_found && break 3
13439     done
13440   done
13441   done
13442 IFS=$as_save_IFS
13443   if test -z "$ac_cv_path_GREP"; then
13444     as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
13445   fi
13446 else
13447   ac_cv_path_GREP=$GREP
13448 fi
13449 
13450 fi
13451 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
13452 $as_echo "$ac_cv_path_GREP" >&6; }
13453  GREP="$ac_cv_path_GREP"
13454 
13455 
13456     else
13457       # If it succeeded, then it was overridden by the user. We will use it
13458       # for the tool.
13459 
13460       # First remove it from the list of overridden variables, so we can test
13461       # for unknown variables in the end.
13462       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13463 
13464       # Check if we try to supply an empty value
13465       if test "x$GREP" = x; then
13466         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool GREP= (no value)" >&5
13467 $as_echo "$as_me: Setting user supplied tool GREP= (no value)" >&6;}
13468         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GREP" >&5
13469 $as_echo_n "checking for GREP... " >&6; }
13470         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
13471 $as_echo "disabled" >&6; }
13472       else
13473         # Check if the provided tool contains a complete path.
13474         tool_specified="$GREP"
13475         tool_basename="${tool_specified##*/}"
13476         if test "x$tool_basename" = "x$tool_specified"; then
13477           # A command without a complete path is provided, search $PATH.
13478           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool GREP=$tool_basename" >&5
13479 $as_echo "$as_me: Will search for user supplied tool GREP=$tool_basename" >&6;}
13480           # Extract the first word of "$tool_basename", so it can be a program name with args.
13481 set dummy $tool_basename; ac_word=$2
13482 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13483 $as_echo_n "checking for $ac_word... " >&6; }
13484 if ${ac_cv_path_GREP+:} false; then :
13485   $as_echo_n "(cached) " >&6
13486 else
13487   case $GREP in
13488   [\\/]* | ?:[\\/]*)
13489   ac_cv_path_GREP="$GREP" # Let the user override the test with a path.
13490   ;;
13491   *)
13492   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13493 for as_dir in $PATH
13494 do
13495   IFS=$as_save_IFS
13496   test -z "$as_dir" && as_dir=.
13497     for ac_exec_ext in '' $ac_executable_extensions; do
13498   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13499     ac_cv_path_GREP="$as_dir/$ac_word$ac_exec_ext"
13500     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13501     break 2
13502   fi
13503 done
13504   done
13505 IFS=$as_save_IFS
13506 
13507   ;;
13508 esac
13509 fi
13510 GREP=$ac_cv_path_GREP
13511 if test -n "$GREP"; then
13512   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GREP" >&5
13513 $as_echo "$GREP" >&6; }
13514 else
13515   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13516 $as_echo "no" >&6; }
13517 fi
13518 
13519 
13520           if test "x$GREP" = x; then
13521             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13522           fi
13523         else
13524           # Otherwise we believe it is a complete path. Use it as it is.
13525           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool GREP=$tool_specified" >&5
13526 $as_echo "$as_me: Will use user supplied tool GREP=$tool_specified" >&6;}
13527           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GREP" >&5
13528 $as_echo_n "checking for GREP... " >&6; }
13529           if test ! -x "$tool_specified"; then
13530             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13531 $as_echo "not found" >&6; }
13532             as_fn_error $? "User supplied tool GREP=$tool_specified does not exist or is not executable" "$LINENO" 5
13533           fi
13534           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13535 $as_echo "$tool_specified" >&6; }
13536         fi
13537       fi
13538     fi
13539 
13540   fi
13541 
13542 
13543   if test "x$GREP" = x; then
13544     as_fn_error $? "Could not find required tool for GREP" "$LINENO" 5
13545   fi
13546 
13547 
13548 
13549 
13550   # Publish this variable in the help.
13551 
13552 
13553   if [ -z "${EGREP+x}" ]; then
13554     # The variable is not set by user, try to locate tool using the code snippet
13555     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
13556 $as_echo_n "checking for egrep... " >&6; }
13557 if ${ac_cv_path_EGREP+:} false; then :
13558   $as_echo_n "(cached) " >&6
13559 else
13560   if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
13561    then ac_cv_path_EGREP="$GREP -E"
13562    else
13563      if test -z "$EGREP"; then
13564   ac_path_EGREP_found=false
13565   # Loop through the user's path and test for each of PROGNAME-LIST
13566   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13567 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
13568 do
13569   IFS=$as_save_IFS
13570   test -z "$as_dir" && as_dir=.
13571     for ac_prog in egrep; do
13572     for ac_exec_ext in '' $ac_executable_extensions; do
13573       ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
13574       as_fn_executable_p "$ac_path_EGREP" || continue
13575 # Check for GNU ac_path_EGREP and select it if it is found.
13576   # Check for GNU $ac_path_EGREP
13577 case `"$ac_path_EGREP" --version 2>&1` in
13578 *GNU*)
13579   ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
13580 *)
13581   ac_count=0
13582   $as_echo_n 0123456789 >"conftest.in"
13583   while :
13584   do
13585     cat "conftest.in" "conftest.in" >"conftest.tmp"
13586     mv "conftest.tmp" "conftest.in"
13587     cp "conftest.in" "conftest.nl"
13588     $as_echo 'EGREP' >> "conftest.nl"
13589     "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
13590     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
13591     as_fn_arith $ac_count + 1 && ac_count=$as_val
13592     if test $ac_count -gt ${ac_path_EGREP_max-0}; then
13593       # Best one so far, save it but keep looking for a better one
13594       ac_cv_path_EGREP="$ac_path_EGREP"
13595       ac_path_EGREP_max=$ac_count
13596     fi
13597     # 10*(2^10) chars as input seems more than enough
13598     test $ac_count -gt 10 && break
13599   done
13600   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
13601 esac
13602 
13603       $ac_path_EGREP_found && break 3
13604     done
13605   done
13606   done
13607 IFS=$as_save_IFS
13608   if test -z "$ac_cv_path_EGREP"; then
13609     as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
13610   fi
13611 else
13612   ac_cv_path_EGREP=$EGREP
13613 fi
13614 
13615    fi
13616 fi
13617 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
13618 $as_echo "$ac_cv_path_EGREP" >&6; }
13619  EGREP="$ac_cv_path_EGREP"
13620 
13621 
13622   else
13623     # The variable is set, but is it from the command line or the environment?
13624 
13625     # Try to remove the string !EGREP! from our list.
13626     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!EGREP!/}
13627     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
13628       # If it failed, the variable was not from the command line. Ignore it,
13629       # but warn the user (except for BASH, which is always set by the calling BASH).
13630       if test "xEGREP" != xBASH; then
13631         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of EGREP from the environment. Use command line variables instead." >&5
13632 $as_echo "$as_me: WARNING: Ignoring value of EGREP from the environment. Use command line variables instead." >&2;}
13633       fi
13634       # Try to locate tool using the code snippet
13635       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
13636 $as_echo_n "checking for egrep... " >&6; }
13637 if ${ac_cv_path_EGREP+:} false; then :
13638   $as_echo_n "(cached) " >&6
13639 else
13640   if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
13641    then ac_cv_path_EGREP="$GREP -E"
13642    else
13643      if test -z "$EGREP"; then
13644   ac_path_EGREP_found=false
13645   # Loop through the user's path and test for each of PROGNAME-LIST
13646   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13647 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
13648 do
13649   IFS=$as_save_IFS
13650   test -z "$as_dir" && as_dir=.
13651     for ac_prog in egrep; do
13652     for ac_exec_ext in '' $ac_executable_extensions; do
13653       ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
13654       as_fn_executable_p "$ac_path_EGREP" || continue
13655 # Check for GNU ac_path_EGREP and select it if it is found.
13656   # Check for GNU $ac_path_EGREP
13657 case `"$ac_path_EGREP" --version 2>&1` in
13658 *GNU*)
13659   ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
13660 *)
13661   ac_count=0
13662   $as_echo_n 0123456789 >"conftest.in"
13663   while :
13664   do
13665     cat "conftest.in" "conftest.in" >"conftest.tmp"
13666     mv "conftest.tmp" "conftest.in"
13667     cp "conftest.in" "conftest.nl"
13668     $as_echo 'EGREP' >> "conftest.nl"
13669     "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
13670     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
13671     as_fn_arith $ac_count + 1 && ac_count=$as_val
13672     if test $ac_count -gt ${ac_path_EGREP_max-0}; then
13673       # Best one so far, save it but keep looking for a better one
13674       ac_cv_path_EGREP="$ac_path_EGREP"
13675       ac_path_EGREP_max=$ac_count
13676     fi
13677     # 10*(2^10) chars as input seems more than enough
13678     test $ac_count -gt 10 && break
13679   done
13680   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
13681 esac
13682 
13683       $ac_path_EGREP_found && break 3
13684     done
13685   done
13686   done
13687 IFS=$as_save_IFS
13688   if test -z "$ac_cv_path_EGREP"; then
13689     as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
13690   fi
13691 else
13692   ac_cv_path_EGREP=$EGREP
13693 fi
13694 
13695    fi
13696 fi
13697 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
13698 $as_echo "$ac_cv_path_EGREP" >&6; }
13699  EGREP="$ac_cv_path_EGREP"
13700 
13701 
13702     else
13703       # If it succeeded, then it was overridden by the user. We will use it
13704       # for the tool.
13705 
13706       # First remove it from the list of overridden variables, so we can test
13707       # for unknown variables in the end.
13708       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13709 
13710       # Check if we try to supply an empty value
13711       if test "x$EGREP" = x; then
13712         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool EGREP= (no value)" >&5
13713 $as_echo "$as_me: Setting user supplied tool EGREP= (no value)" >&6;}
13714         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EGREP" >&5
13715 $as_echo_n "checking for EGREP... " >&6; }
13716         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
13717 $as_echo "disabled" >&6; }
13718       else
13719         # Check if the provided tool contains a complete path.
13720         tool_specified="$EGREP"
13721         tool_basename="${tool_specified##*/}"
13722         if test "x$tool_basename" = "x$tool_specified"; then
13723           # A command without a complete path is provided, search $PATH.
13724           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool EGREP=$tool_basename" >&5
13725 $as_echo "$as_me: Will search for user supplied tool EGREP=$tool_basename" >&6;}
13726           # Extract the first word of "$tool_basename", so it can be a program name with args.
13727 set dummy $tool_basename; ac_word=$2
13728 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13729 $as_echo_n "checking for $ac_word... " >&6; }
13730 if ${ac_cv_path_EGREP+:} false; then :
13731   $as_echo_n "(cached) " >&6
13732 else
13733   case $EGREP in
13734   [\\/]* | ?:[\\/]*)
13735   ac_cv_path_EGREP="$EGREP" # Let the user override the test with a path.
13736   ;;
13737   *)
13738   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13739 for as_dir in $PATH
13740 do
13741   IFS=$as_save_IFS
13742   test -z "$as_dir" && as_dir=.
13743     for ac_exec_ext in '' $ac_executable_extensions; do
13744   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13745     ac_cv_path_EGREP="$as_dir/$ac_word$ac_exec_ext"
13746     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13747     break 2
13748   fi
13749 done
13750   done
13751 IFS=$as_save_IFS
13752 
13753   ;;
13754 esac
13755 fi
13756 EGREP=$ac_cv_path_EGREP
13757 if test -n "$EGREP"; then
13758   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EGREP" >&5
13759 $as_echo "$EGREP" >&6; }
13760 else
13761   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13762 $as_echo "no" >&6; }
13763 fi
13764 
13765 
13766           if test "x$EGREP" = x; then
13767             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13768           fi
13769         else
13770           # Otherwise we believe it is a complete path. Use it as it is.
13771           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool EGREP=$tool_specified" >&5
13772 $as_echo "$as_me: Will use user supplied tool EGREP=$tool_specified" >&6;}
13773           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EGREP" >&5
13774 $as_echo_n "checking for EGREP... " >&6; }
13775           if test ! -x "$tool_specified"; then
13776             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13777 $as_echo "not found" >&6; }
13778             as_fn_error $? "User supplied tool EGREP=$tool_specified does not exist or is not executable" "$LINENO" 5
13779           fi
13780           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13781 $as_echo "$tool_specified" >&6; }
13782         fi
13783       fi
13784     fi
13785 
13786   fi
13787 
13788 
13789   if test "x$EGREP" = x; then
13790     as_fn_error $? "Could not find required tool for EGREP" "$LINENO" 5
13791   fi
13792 
13793 
13794 
13795 
13796   # Publish this variable in the help.
13797 
13798 
13799   if [ -z "${FGREP+x}" ]; then
13800     # The variable is not set by user, try to locate tool using the code snippet
13801     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
13802 $as_echo_n "checking for fgrep... " >&6; }
13803 if ${ac_cv_path_FGREP+:} false; then :
13804   $as_echo_n "(cached) " >&6
13805 else
13806   if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
13807    then ac_cv_path_FGREP="$GREP -F"
13808    else
13809      if test -z "$FGREP"; then
13810   ac_path_FGREP_found=false
13811   # Loop through the user's path and test for each of PROGNAME-LIST
13812   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13813 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
13814 do
13815   IFS=$as_save_IFS
13816   test -z "$as_dir" && as_dir=.
13817     for ac_prog in fgrep; do
13818     for ac_exec_ext in '' $ac_executable_extensions; do
13819       ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
13820       as_fn_executable_p "$ac_path_FGREP" || continue
13821 # Check for GNU ac_path_FGREP and select it if it is found.
13822   # Check for GNU $ac_path_FGREP
13823 case `"$ac_path_FGREP" --version 2>&1` in
13824 *GNU*)
13825   ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
13826 *)
13827   ac_count=0
13828   $as_echo_n 0123456789 >"conftest.in"
13829   while :
13830   do
13831     cat "conftest.in" "conftest.in" >"conftest.tmp"
13832     mv "conftest.tmp" "conftest.in"
13833     cp "conftest.in" "conftest.nl"
13834     $as_echo 'FGREP' >> "conftest.nl"
13835     "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
13836     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
13837     as_fn_arith $ac_count + 1 && ac_count=$as_val
13838     if test $ac_count -gt ${ac_path_FGREP_max-0}; then
13839       # Best one so far, save it but keep looking for a better one
13840       ac_cv_path_FGREP="$ac_path_FGREP"
13841       ac_path_FGREP_max=$ac_count
13842     fi
13843     # 10*(2^10) chars as input seems more than enough
13844     test $ac_count -gt 10 && break
13845   done
13846   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
13847 esac
13848 
13849       $ac_path_FGREP_found && break 3
13850     done
13851   done
13852   done
13853 IFS=$as_save_IFS
13854   if test -z "$ac_cv_path_FGREP"; then
13855     as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
13856   fi
13857 else
13858   ac_cv_path_FGREP=$FGREP
13859 fi
13860 
13861    fi
13862 fi
13863 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
13864 $as_echo "$ac_cv_path_FGREP" >&6; }
13865  FGREP="$ac_cv_path_FGREP"
13866 
13867 
13868   else
13869     # The variable is set, but is it from the command line or the environment?
13870 
13871     # Try to remove the string !FGREP! from our list.
13872     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FGREP!/}
13873     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
13874       # If it failed, the variable was not from the command line. Ignore it,
13875       # but warn the user (except for BASH, which is always set by the calling BASH).
13876       if test "xFGREP" != xBASH; then
13877         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FGREP from the environment. Use command line variables instead." >&5
13878 $as_echo "$as_me: WARNING: Ignoring value of FGREP from the environment. Use command line variables instead." >&2;}
13879       fi
13880       # Try to locate tool using the code snippet
13881       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
13882 $as_echo_n "checking for fgrep... " >&6; }
13883 if ${ac_cv_path_FGREP+:} false; then :
13884   $as_echo_n "(cached) " >&6
13885 else
13886   if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
13887    then ac_cv_path_FGREP="$GREP -F"
13888    else
13889      if test -z "$FGREP"; then
13890   ac_path_FGREP_found=false
13891   # Loop through the user's path and test for each of PROGNAME-LIST
13892   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13893 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
13894 do
13895   IFS=$as_save_IFS
13896   test -z "$as_dir" && as_dir=.
13897     for ac_prog in fgrep; do
13898     for ac_exec_ext in '' $ac_executable_extensions; do
13899       ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
13900       as_fn_executable_p "$ac_path_FGREP" || continue
13901 # Check for GNU ac_path_FGREP and select it if it is found.
13902   # Check for GNU $ac_path_FGREP
13903 case `"$ac_path_FGREP" --version 2>&1` in
13904 *GNU*)
13905   ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
13906 *)
13907   ac_count=0
13908   $as_echo_n 0123456789 >"conftest.in"
13909   while :
13910   do
13911     cat "conftest.in" "conftest.in" >"conftest.tmp"
13912     mv "conftest.tmp" "conftest.in"
13913     cp "conftest.in" "conftest.nl"
13914     $as_echo 'FGREP' >> "conftest.nl"
13915     "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
13916     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
13917     as_fn_arith $ac_count + 1 && ac_count=$as_val
13918     if test $ac_count -gt ${ac_path_FGREP_max-0}; then
13919       # Best one so far, save it but keep looking for a better one
13920       ac_cv_path_FGREP="$ac_path_FGREP"
13921       ac_path_FGREP_max=$ac_count
13922     fi
13923     # 10*(2^10) chars as input seems more than enough
13924     test $ac_count -gt 10 && break
13925   done
13926   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
13927 esac
13928 
13929       $ac_path_FGREP_found && break 3
13930     done
13931   done
13932   done
13933 IFS=$as_save_IFS
13934   if test -z "$ac_cv_path_FGREP"; then
13935     as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
13936   fi
13937 else
13938   ac_cv_path_FGREP=$FGREP
13939 fi
13940 
13941    fi
13942 fi
13943 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
13944 $as_echo "$ac_cv_path_FGREP" >&6; }
13945  FGREP="$ac_cv_path_FGREP"
13946 
13947 
13948     else
13949       # If it succeeded, then it was overridden by the user. We will use it
13950       # for the tool.
13951 
13952       # First remove it from the list of overridden variables, so we can test
13953       # for unknown variables in the end.
13954       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13955 
13956       # Check if we try to supply an empty value
13957       if test "x$FGREP" = x; then
13958         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool FGREP= (no value)" >&5
13959 $as_echo "$as_me: Setting user supplied tool FGREP= (no value)" >&6;}
13960         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FGREP" >&5
13961 $as_echo_n "checking for FGREP... " >&6; }
13962         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
13963 $as_echo "disabled" >&6; }
13964       else
13965         # Check if the provided tool contains a complete path.
13966         tool_specified="$FGREP"
13967         tool_basename="${tool_specified##*/}"
13968         if test "x$tool_basename" = "x$tool_specified"; then
13969           # A command without a complete path is provided, search $PATH.
13970           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FGREP=$tool_basename" >&5
13971 $as_echo "$as_me: Will search for user supplied tool FGREP=$tool_basename" >&6;}
13972           # Extract the first word of "$tool_basename", so it can be a program name with args.
13973 set dummy $tool_basename; ac_word=$2
13974 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13975 $as_echo_n "checking for $ac_word... " >&6; }
13976 if ${ac_cv_path_FGREP+:} false; then :
13977   $as_echo_n "(cached) " >&6
13978 else
13979   case $FGREP in
13980   [\\/]* | ?:[\\/]*)
13981   ac_cv_path_FGREP="$FGREP" # Let the user override the test with a path.
13982   ;;
13983   *)
13984   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13985 for as_dir in $PATH
13986 do
13987   IFS=$as_save_IFS
13988   test -z "$as_dir" && as_dir=.
13989     for ac_exec_ext in '' $ac_executable_extensions; do
13990   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13991     ac_cv_path_FGREP="$as_dir/$ac_word$ac_exec_ext"
13992     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13993     break 2
13994   fi
13995 done
13996   done
13997 IFS=$as_save_IFS
13998 
13999   ;;
14000 esac
14001 fi
14002 FGREP=$ac_cv_path_FGREP
14003 if test -n "$FGREP"; then
14004   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FGREP" >&5
14005 $as_echo "$FGREP" >&6; }
14006 else
14007   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14008 $as_echo "no" >&6; }
14009 fi
14010 
14011 
14012           if test "x$FGREP" = x; then
14013             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
14014           fi
14015         else
14016           # Otherwise we believe it is a complete path. Use it as it is.
14017           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FGREP=$tool_specified" >&5
14018 $as_echo "$as_me: Will use user supplied tool FGREP=$tool_specified" >&6;}
14019           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FGREP" >&5
14020 $as_echo_n "checking for FGREP... " >&6; }
14021           if test ! -x "$tool_specified"; then
14022             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
14023 $as_echo "not found" >&6; }
14024             as_fn_error $? "User supplied tool FGREP=$tool_specified does not exist or is not executable" "$LINENO" 5
14025           fi
14026           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
14027 $as_echo "$tool_specified" >&6; }
14028         fi
14029       fi
14030     fi
14031 
14032   fi
14033 
14034 
14035   if test "x$FGREP" = x; then
14036     as_fn_error $? "Could not find required tool for FGREP" "$LINENO" 5
14037   fi
14038 
14039 
14040 
14041 
14042   # Publish this variable in the help.
14043 
14044 
14045   if [ -z "${SED+x}" ]; then
14046     # The variable is not set by user, try to locate tool using the code snippet
14047     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
14048 $as_echo_n "checking for a sed that does not truncate output... " >&6; }
14049 if ${ac_cv_path_SED+:} false; then :
14050   $as_echo_n "(cached) " >&6
14051 else
14052             ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
14053      for ac_i in 1 2 3 4 5 6 7; do
14054        ac_script="$ac_script$as_nl$ac_script"
14055      done
14056      echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
14057      { ac_script=; unset ac_script;}
14058      if test -z "$SED"; then
14059   ac_path_SED_found=false
14060   # Loop through the user's path and test for each of PROGNAME-LIST
14061   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14062 for as_dir in $PATH
14063 do
14064   IFS=$as_save_IFS
14065   test -z "$as_dir" && as_dir=.
14066     for ac_prog in sed gsed; do
14067     for ac_exec_ext in '' $ac_executable_extensions; do
14068       ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
14069       as_fn_executable_p "$ac_path_SED" || continue
14070 # Check for GNU ac_path_SED and select it if it is found.
14071   # Check for GNU $ac_path_SED
14072 case `"$ac_path_SED" --version 2>&1` in
14073 *GNU*)
14074   ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
14075 *)
14076   ac_count=0
14077   $as_echo_n 0123456789 >"conftest.in"
14078   while :
14079   do
14080     cat "conftest.in" "conftest.in" >"conftest.tmp"
14081     mv "conftest.tmp" "conftest.in"
14082     cp "conftest.in" "conftest.nl"
14083     $as_echo '' >> "conftest.nl"
14084     "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
14085     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
14086     as_fn_arith $ac_count + 1 && ac_count=$as_val
14087     if test $ac_count -gt ${ac_path_SED_max-0}; then
14088       # Best one so far, save it but keep looking for a better one
14089       ac_cv_path_SED="$ac_path_SED"
14090       ac_path_SED_max=$ac_count
14091     fi
14092     # 10*(2^10) chars as input seems more than enough
14093     test $ac_count -gt 10 && break
14094   done
14095   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
14096 esac
14097 
14098       $ac_path_SED_found && break 3
14099     done
14100   done
14101   done
14102 IFS=$as_save_IFS
14103   if test -z "$ac_cv_path_SED"; then
14104     as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
14105   fi
14106 else
14107   ac_cv_path_SED=$SED
14108 fi
14109 
14110 fi
14111 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
14112 $as_echo "$ac_cv_path_SED" >&6; }
14113  SED="$ac_cv_path_SED"
14114   rm -f conftest.sed
14115 
14116   else
14117     # The variable is set, but is it from the command line or the environment?
14118 
14119     # Try to remove the string !SED! from our list.
14120     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SED!/}
14121     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
14122       # If it failed, the variable was not from the command line. Ignore it,
14123       # but warn the user (except for BASH, which is always set by the calling BASH).
14124       if test "xSED" != xBASH; then
14125         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SED from the environment. Use command line variables instead." >&5
14126 $as_echo "$as_me: WARNING: Ignoring value of SED from the environment. Use command line variables instead." >&2;}
14127       fi
14128       # Try to locate tool using the code snippet
14129       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
14130 $as_echo_n "checking for a sed that does not truncate output... " >&6; }
14131 if ${ac_cv_path_SED+:} false; then :
14132   $as_echo_n "(cached) " >&6
14133 else
14134             ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
14135      for ac_i in 1 2 3 4 5 6 7; do
14136        ac_script="$ac_script$as_nl$ac_script"
14137      done
14138      echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
14139      { ac_script=; unset ac_script;}
14140      if test -z "$SED"; then
14141   ac_path_SED_found=false
14142   # Loop through the user's path and test for each of PROGNAME-LIST
14143   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14144 for as_dir in $PATH
14145 do
14146   IFS=$as_save_IFS
14147   test -z "$as_dir" && as_dir=.
14148     for ac_prog in sed gsed; do
14149     for ac_exec_ext in '' $ac_executable_extensions; do
14150       ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
14151       as_fn_executable_p "$ac_path_SED" || continue
14152 # Check for GNU ac_path_SED and select it if it is found.
14153   # Check for GNU $ac_path_SED
14154 case `"$ac_path_SED" --version 2>&1` in
14155 *GNU*)
14156   ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
14157 *)
14158   ac_count=0
14159   $as_echo_n 0123456789 >"conftest.in"
14160   while :
14161   do
14162     cat "conftest.in" "conftest.in" >"conftest.tmp"
14163     mv "conftest.tmp" "conftest.in"
14164     cp "conftest.in" "conftest.nl"
14165     $as_echo '' >> "conftest.nl"
14166     "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
14167     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
14168     as_fn_arith $ac_count + 1 && ac_count=$as_val
14169     if test $ac_count -gt ${ac_path_SED_max-0}; then
14170       # Best one so far, save it but keep looking for a better one
14171       ac_cv_path_SED="$ac_path_SED"
14172       ac_path_SED_max=$ac_count
14173     fi
14174     # 10*(2^10) chars as input seems more than enough
14175     test $ac_count -gt 10 && break
14176   done
14177   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
14178 esac
14179 
14180       $ac_path_SED_found && break 3
14181     done
14182   done
14183   done
14184 IFS=$as_save_IFS
14185   if test -z "$ac_cv_path_SED"; then
14186     as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
14187   fi
14188 else
14189   ac_cv_path_SED=$SED
14190 fi
14191 
14192 fi
14193 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
14194 $as_echo "$ac_cv_path_SED" >&6; }
14195  SED="$ac_cv_path_SED"
14196   rm -f conftest.sed
14197 
14198     else
14199       # If it succeeded, then it was overridden by the user. We will use it
14200       # for the tool.
14201 
14202       # First remove it from the list of overridden variables, so we can test
14203       # for unknown variables in the end.
14204       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
14205 
14206       # Check if we try to supply an empty value
14207       if test "x$SED" = x; then
14208         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool SED= (no value)" >&5
14209 $as_echo "$as_me: Setting user supplied tool SED= (no value)" >&6;}
14210         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SED" >&5
14211 $as_echo_n "checking for SED... " >&6; }
14212         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
14213 $as_echo "disabled" >&6; }
14214       else
14215         # Check if the provided tool contains a complete path.
14216         tool_specified="$SED"
14217         tool_basename="${tool_specified##*/}"
14218         if test "x$tool_basename" = "x$tool_specified"; then
14219           # A command without a complete path is provided, search $PATH.
14220           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SED=$tool_basename" >&5
14221 $as_echo "$as_me: Will search for user supplied tool SED=$tool_basename" >&6;}
14222           # Extract the first word of "$tool_basename", so it can be a program name with args.
14223 set dummy $tool_basename; ac_word=$2
14224 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14225 $as_echo_n "checking for $ac_word... " >&6; }
14226 if ${ac_cv_path_SED+:} false; then :
14227   $as_echo_n "(cached) " >&6
14228 else
14229   case $SED in
14230   [\\/]* | ?:[\\/]*)
14231   ac_cv_path_SED="$SED" # Let the user override the test with a path.
14232   ;;
14233   *)
14234   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14235 for as_dir in $PATH
14236 do
14237   IFS=$as_save_IFS
14238   test -z "$as_dir" && as_dir=.
14239     for ac_exec_ext in '' $ac_executable_extensions; do
14240   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14241     ac_cv_path_SED="$as_dir/$ac_word$ac_exec_ext"
14242     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14243     break 2
14244   fi
14245 done
14246   done
14247 IFS=$as_save_IFS
14248 
14249   ;;
14250 esac
14251 fi
14252 SED=$ac_cv_path_SED
14253 if test -n "$SED"; then
14254   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SED" >&5
14255 $as_echo "$SED" >&6; }
14256 else
14257   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14258 $as_echo "no" >&6; }
14259 fi
14260 
14261 
14262           if test "x$SED" = x; then
14263             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
14264           fi
14265         else
14266           # Otherwise we believe it is a complete path. Use it as it is.
14267           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SED=$tool_specified" >&5
14268 $as_echo "$as_me: Will use user supplied tool SED=$tool_specified" >&6;}
14269           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SED" >&5
14270 $as_echo_n "checking for SED... " >&6; }
14271           if test ! -x "$tool_specified"; then
14272             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
14273 $as_echo "not found" >&6; }
14274             as_fn_error $? "User supplied tool SED=$tool_specified does not exist or is not executable" "$LINENO" 5
14275           fi
14276           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
14277 $as_echo "$tool_specified" >&6; }
14278         fi
14279       fi
14280     fi
14281 
14282   fi
14283 
14284 
14285   if test "x$SED" = x; then
14286     as_fn_error $? "Could not find required tool for SED" "$LINENO" 5
14287   fi
14288 
14289 
14290 
14291   # Always force rm.
14292   RM="$RM -f"
14293 
14294   # pwd behaves differently on various platforms and some don't support the -L flag.
14295   # Always use the bash builtin pwd to get uniform behavior.
14296   THEPWDCMD=pwd
14297 
14298   # These are not required on all platforms
14299 
14300 
14301   # Publish this variable in the help.
14302 
14303 
14304   if [ -z "${CYGPATH+x}" ]; then
14305     # The variable is not set by user, try to locate tool using the code snippet
14306     for ac_prog in cygpath
14307 do
14308   # Extract the first word of "$ac_prog", so it can be a program name with args.
14309 set dummy $ac_prog; ac_word=$2
14310 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14311 $as_echo_n "checking for $ac_word... " >&6; }
14312 if ${ac_cv_path_CYGPATH+:} false; then :
14313   $as_echo_n "(cached) " >&6
14314 else
14315   case $CYGPATH in
14316   [\\/]* | ?:[\\/]*)
14317   ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
14318   ;;
14319   *)
14320   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14321 for as_dir in $PATH
14322 do
14323   IFS=$as_save_IFS
14324   test -z "$as_dir" && as_dir=.
14325     for ac_exec_ext in '' $ac_executable_extensions; do
14326   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14327     ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
14328     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14329     break 2
14330   fi
14331 done
14332   done
14333 IFS=$as_save_IFS
14334 
14335   ;;
14336 esac
14337 fi
14338 CYGPATH=$ac_cv_path_CYGPATH
14339 if test -n "$CYGPATH"; then
14340   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
14341 $as_echo "$CYGPATH" >&6; }
14342 else
14343   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14344 $as_echo "no" >&6; }
14345 fi
14346 
14347 
14348   test -n "$CYGPATH" && break
14349 done
14350 
14351   else
14352     # The variable is set, but is it from the command line or the environment?
14353 
14354     # Try to remove the string !CYGPATH! from our list.
14355     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CYGPATH!/}
14356     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
14357       # If it failed, the variable was not from the command line. Ignore it,
14358       # but warn the user (except for BASH, which is always set by the calling BASH).
14359       if test "xCYGPATH" != xBASH; then
14360         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CYGPATH from the environment. Use command line variables instead." >&5
14361 $as_echo "$as_me: WARNING: Ignoring value of CYGPATH from the environment. Use command line variables instead." >&2;}
14362       fi
14363       # Try to locate tool using the code snippet
14364       for ac_prog in cygpath
14365 do
14366   # Extract the first word of "$ac_prog", so it can be a program name with args.
14367 set dummy $ac_prog; ac_word=$2
14368 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14369 $as_echo_n "checking for $ac_word... " >&6; }
14370 if ${ac_cv_path_CYGPATH+:} false; then :
14371   $as_echo_n "(cached) " >&6
14372 else
14373   case $CYGPATH in
14374   [\\/]* | ?:[\\/]*)
14375   ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
14376   ;;
14377   *)
14378   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14379 for as_dir in $PATH
14380 do
14381   IFS=$as_save_IFS
14382   test -z "$as_dir" && as_dir=.
14383     for ac_exec_ext in '' $ac_executable_extensions; do
14384   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14385     ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
14386     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14387     break 2
14388   fi
14389 done
14390   done
14391 IFS=$as_save_IFS
14392 
14393   ;;
14394 esac
14395 fi
14396 CYGPATH=$ac_cv_path_CYGPATH
14397 if test -n "$CYGPATH"; then
14398   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
14399 $as_echo "$CYGPATH" >&6; }
14400 else
14401   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14402 $as_echo "no" >&6; }
14403 fi
14404 
14405 
14406   test -n "$CYGPATH" && break
14407 done
14408 
14409     else
14410       # If it succeeded, then it was overridden by the user. We will use it
14411       # for the tool.
14412 
14413       # First remove it from the list of overridden variables, so we can test
14414       # for unknown variables in the end.
14415       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
14416 
14417       # Check if we try to supply an empty value
14418       if test "x$CYGPATH" = x; then
14419         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CYGPATH= (no value)" >&5
14420 $as_echo "$as_me: Setting user supplied tool CYGPATH= (no value)" >&6;}
14421         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CYGPATH" >&5
14422 $as_echo_n "checking for CYGPATH... " >&6; }
14423         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
14424 $as_echo "disabled" >&6; }
14425       else
14426         # Check if the provided tool contains a complete path.
14427         tool_specified="$CYGPATH"
14428         tool_basename="${tool_specified##*/}"
14429         if test "x$tool_basename" = "x$tool_specified"; then
14430           # A command without a complete path is provided, search $PATH.
14431           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CYGPATH=$tool_basename" >&5
14432 $as_echo "$as_me: Will search for user supplied tool CYGPATH=$tool_basename" >&6;}
14433           # Extract the first word of "$tool_basename", so it can be a program name with args.
14434 set dummy $tool_basename; ac_word=$2
14435 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14436 $as_echo_n "checking for $ac_word... " >&6; }
14437 if ${ac_cv_path_CYGPATH+:} false; then :
14438   $as_echo_n "(cached) " >&6
14439 else
14440   case $CYGPATH in
14441   [\\/]* | ?:[\\/]*)
14442   ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
14443   ;;
14444   *)
14445   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14446 for as_dir in $PATH
14447 do
14448   IFS=$as_save_IFS
14449   test -z "$as_dir" && as_dir=.
14450     for ac_exec_ext in '' $ac_executable_extensions; do
14451   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14452     ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
14453     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14454     break 2
14455   fi
14456 done
14457   done
14458 IFS=$as_save_IFS
14459 
14460   ;;
14461 esac
14462 fi
14463 CYGPATH=$ac_cv_path_CYGPATH
14464 if test -n "$CYGPATH"; then
14465   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
14466 $as_echo "$CYGPATH" >&6; }
14467 else
14468   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14469 $as_echo "no" >&6; }
14470 fi
14471 
14472 
14473           if test "x$CYGPATH" = x; then
14474             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
14475           fi
14476         else
14477           # Otherwise we believe it is a complete path. Use it as it is.
14478           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CYGPATH=$tool_specified" >&5
14479 $as_echo "$as_me: Will use user supplied tool CYGPATH=$tool_specified" >&6;}
14480           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CYGPATH" >&5
14481 $as_echo_n "checking for CYGPATH... " >&6; }
14482           if test ! -x "$tool_specified"; then
14483             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
14484 $as_echo "not found" >&6; }
14485             as_fn_error $? "User supplied tool CYGPATH=$tool_specified does not exist or is not executable" "$LINENO" 5
14486           fi
14487           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
14488 $as_echo "$tool_specified" >&6; }
14489         fi
14490       fi
14491     fi
14492 
14493   fi
14494 
14495 
14496 
14497 
14498   # Publish this variable in the help.
14499 
14500 
14501   if [ -z "${READLINK+x}" ]; then
14502     # The variable is not set by user, try to locate tool using the code snippet
14503     for ac_prog in greadlink readlink
14504 do
14505   # Extract the first word of "$ac_prog", so it can be a program name with args.
14506 set dummy $ac_prog; ac_word=$2
14507 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14508 $as_echo_n "checking for $ac_word... " >&6; }
14509 if ${ac_cv_path_READLINK+:} false; then :
14510   $as_echo_n "(cached) " >&6
14511 else
14512   case $READLINK in
14513   [\\/]* | ?:[\\/]*)
14514   ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
14515   ;;
14516   *)
14517   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14518 for as_dir in $PATH
14519 do
14520   IFS=$as_save_IFS
14521   test -z "$as_dir" && as_dir=.
14522     for ac_exec_ext in '' $ac_executable_extensions; do
14523   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14524     ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
14525     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14526     break 2
14527   fi
14528 done
14529   done
14530 IFS=$as_save_IFS
14531 
14532   ;;
14533 esac
14534 fi
14535 READLINK=$ac_cv_path_READLINK
14536 if test -n "$READLINK"; then
14537   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
14538 $as_echo "$READLINK" >&6; }
14539 else
14540   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14541 $as_echo "no" >&6; }
14542 fi
14543 
14544 
14545   test -n "$READLINK" && break
14546 done
14547 
14548   else
14549     # The variable is set, but is it from the command line or the environment?
14550 
14551     # Try to remove the string !READLINK! from our list.
14552     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!READLINK!/}
14553     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
14554       # If it failed, the variable was not from the command line. Ignore it,
14555       # but warn the user (except for BASH, which is always set by the calling BASH).
14556       if test "xREADLINK" != xBASH; then
14557         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of READLINK from the environment. Use command line variables instead." >&5
14558 $as_echo "$as_me: WARNING: Ignoring value of READLINK from the environment. Use command line variables instead." >&2;}
14559       fi
14560       # Try to locate tool using the code snippet
14561       for ac_prog in greadlink readlink
14562 do
14563   # Extract the first word of "$ac_prog", so it can be a program name with args.
14564 set dummy $ac_prog; ac_word=$2
14565 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14566 $as_echo_n "checking for $ac_word... " >&6; }
14567 if ${ac_cv_path_READLINK+:} false; then :
14568   $as_echo_n "(cached) " >&6
14569 else
14570   case $READLINK in
14571   [\\/]* | ?:[\\/]*)
14572   ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
14573   ;;
14574   *)
14575   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14576 for as_dir in $PATH
14577 do
14578   IFS=$as_save_IFS
14579   test -z "$as_dir" && as_dir=.
14580     for ac_exec_ext in '' $ac_executable_extensions; do
14581   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14582     ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
14583     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14584     break 2
14585   fi
14586 done
14587   done
14588 IFS=$as_save_IFS
14589 
14590   ;;
14591 esac
14592 fi
14593 READLINK=$ac_cv_path_READLINK
14594 if test -n "$READLINK"; then
14595   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
14596 $as_echo "$READLINK" >&6; }
14597 else
14598   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14599 $as_echo "no" >&6; }
14600 fi
14601 
14602 
14603   test -n "$READLINK" && break
14604 done
14605 
14606     else
14607       # If it succeeded, then it was overridden by the user. We will use it
14608       # for the tool.
14609 
14610       # First remove it from the list of overridden variables, so we can test
14611       # for unknown variables in the end.
14612       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
14613 
14614       # Check if we try to supply an empty value
14615       if test "x$READLINK" = x; then
14616         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool READLINK= (no value)" >&5
14617 $as_echo "$as_me: Setting user supplied tool READLINK= (no value)" >&6;}
14618         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READLINK" >&5
14619 $as_echo_n "checking for READLINK... " >&6; }
14620         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
14621 $as_echo "disabled" >&6; }
14622       else
14623         # Check if the provided tool contains a complete path.
14624         tool_specified="$READLINK"
14625         tool_basename="${tool_specified##*/}"
14626         if test "x$tool_basename" = "x$tool_specified"; then
14627           # A command without a complete path is provided, search $PATH.
14628           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool READLINK=$tool_basename" >&5
14629 $as_echo "$as_me: Will search for user supplied tool READLINK=$tool_basename" >&6;}
14630           # Extract the first word of "$tool_basename", so it can be a program name with args.
14631 set dummy $tool_basename; ac_word=$2
14632 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14633 $as_echo_n "checking for $ac_word... " >&6; }
14634 if ${ac_cv_path_READLINK+:} false; then :
14635   $as_echo_n "(cached) " >&6
14636 else
14637   case $READLINK in
14638   [\\/]* | ?:[\\/]*)
14639   ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
14640   ;;
14641   *)
14642   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14643 for as_dir in $PATH
14644 do
14645   IFS=$as_save_IFS
14646   test -z "$as_dir" && as_dir=.
14647     for ac_exec_ext in '' $ac_executable_extensions; do
14648   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14649     ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
14650     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14651     break 2
14652   fi
14653 done
14654   done
14655 IFS=$as_save_IFS
14656 
14657   ;;
14658 esac
14659 fi
14660 READLINK=$ac_cv_path_READLINK
14661 if test -n "$READLINK"; then
14662   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
14663 $as_echo "$READLINK" >&6; }
14664 else
14665   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14666 $as_echo "no" >&6; }
14667 fi
14668 
14669 
14670           if test "x$READLINK" = x; then
14671             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
14672           fi
14673         else
14674           # Otherwise we believe it is a complete path. Use it as it is.
14675           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool READLINK=$tool_specified" >&5
14676 $as_echo "$as_me: Will use user supplied tool READLINK=$tool_specified" >&6;}
14677           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READLINK" >&5
14678 $as_echo_n "checking for READLINK... " >&6; }
14679           if test ! -x "$tool_specified"; then
14680             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
14681 $as_echo "not found" >&6; }
14682             as_fn_error $? "User supplied tool READLINK=$tool_specified does not exist or is not executable" "$LINENO" 5
14683           fi
14684           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
14685 $as_echo "$tool_specified" >&6; }
14686         fi
14687       fi
14688     fi
14689 
14690   fi
14691 
14692 
14693 
14694 
14695   # Publish this variable in the help.
14696 
14697 
14698   if [ -z "${DF+x}" ]; then
14699     # The variable is not set by user, try to locate tool using the code snippet
14700     for ac_prog in df
14701 do
14702   # Extract the first word of "$ac_prog", so it can be a program name with args.
14703 set dummy $ac_prog; ac_word=$2
14704 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14705 $as_echo_n "checking for $ac_word... " >&6; }
14706 if ${ac_cv_path_DF+:} false; then :
14707   $as_echo_n "(cached) " >&6
14708 else
14709   case $DF in
14710   [\\/]* | ?:[\\/]*)
14711   ac_cv_path_DF="$DF" # Let the user override the test with a path.
14712   ;;
14713   *)
14714   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14715 for as_dir in $PATH
14716 do
14717   IFS=$as_save_IFS
14718   test -z "$as_dir" && as_dir=.
14719     for ac_exec_ext in '' $ac_executable_extensions; do
14720   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14721     ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
14722     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14723     break 2
14724   fi
14725 done
14726   done
14727 IFS=$as_save_IFS
14728 
14729   ;;
14730 esac
14731 fi
14732 DF=$ac_cv_path_DF
14733 if test -n "$DF"; then
14734   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
14735 $as_echo "$DF" >&6; }
14736 else
14737   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14738 $as_echo "no" >&6; }
14739 fi
14740 
14741 
14742   test -n "$DF" && break
14743 done
14744 
14745   else
14746     # The variable is set, but is it from the command line or the environment?
14747 
14748     # Try to remove the string !DF! from our list.
14749     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DF!/}
14750     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
14751       # If it failed, the variable was not from the command line. Ignore it,
14752       # but warn the user (except for BASH, which is always set by the calling BASH).
14753       if test "xDF" != xBASH; then
14754         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DF from the environment. Use command line variables instead." >&5
14755 $as_echo "$as_me: WARNING: Ignoring value of DF from the environment. Use command line variables instead." >&2;}
14756       fi
14757       # Try to locate tool using the code snippet
14758       for ac_prog in df
14759 do
14760   # Extract the first word of "$ac_prog", so it can be a program name with args.
14761 set dummy $ac_prog; ac_word=$2
14762 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14763 $as_echo_n "checking for $ac_word... " >&6; }
14764 if ${ac_cv_path_DF+:} false; then :
14765   $as_echo_n "(cached) " >&6
14766 else
14767   case $DF in
14768   [\\/]* | ?:[\\/]*)
14769   ac_cv_path_DF="$DF" # Let the user override the test with a path.
14770   ;;
14771   *)
14772   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14773 for as_dir in $PATH
14774 do
14775   IFS=$as_save_IFS
14776   test -z "$as_dir" && as_dir=.
14777     for ac_exec_ext in '' $ac_executable_extensions; do
14778   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14779     ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
14780     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14781     break 2
14782   fi
14783 done
14784   done
14785 IFS=$as_save_IFS
14786 
14787   ;;
14788 esac
14789 fi
14790 DF=$ac_cv_path_DF
14791 if test -n "$DF"; then
14792   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
14793 $as_echo "$DF" >&6; }
14794 else
14795   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14796 $as_echo "no" >&6; }
14797 fi
14798 
14799 
14800   test -n "$DF" && break
14801 done
14802 
14803     else
14804       # If it succeeded, then it was overridden by the user. We will use it
14805       # for the tool.
14806 
14807       # First remove it from the list of overridden variables, so we can test
14808       # for unknown variables in the end.
14809       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
14810 
14811       # Check if we try to supply an empty value
14812       if test "x$DF" = x; then
14813         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool DF= (no value)" >&5
14814 $as_echo "$as_me: Setting user supplied tool DF= (no value)" >&6;}
14815         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DF" >&5
14816 $as_echo_n "checking for DF... " >&6; }
14817         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
14818 $as_echo "disabled" >&6; }
14819       else
14820         # Check if the provided tool contains a complete path.
14821         tool_specified="$DF"
14822         tool_basename="${tool_specified##*/}"
14823         if test "x$tool_basename" = "x$tool_specified"; then
14824           # A command without a complete path is provided, search $PATH.
14825           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DF=$tool_basename" >&5
14826 $as_echo "$as_me: Will search for user supplied tool DF=$tool_basename" >&6;}
14827           # Extract the first word of "$tool_basename", so it can be a program name with args.
14828 set dummy $tool_basename; ac_word=$2
14829 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14830 $as_echo_n "checking for $ac_word... " >&6; }
14831 if ${ac_cv_path_DF+:} false; then :
14832   $as_echo_n "(cached) " >&6
14833 else
14834   case $DF in
14835   [\\/]* | ?:[\\/]*)
14836   ac_cv_path_DF="$DF" # Let the user override the test with a path.
14837   ;;
14838   *)
14839   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14840 for as_dir in $PATH
14841 do
14842   IFS=$as_save_IFS
14843   test -z "$as_dir" && as_dir=.
14844     for ac_exec_ext in '' $ac_executable_extensions; do
14845   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14846     ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
14847     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14848     break 2
14849   fi
14850 done
14851   done
14852 IFS=$as_save_IFS
14853 
14854   ;;
14855 esac
14856 fi
14857 DF=$ac_cv_path_DF
14858 if test -n "$DF"; then
14859   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
14860 $as_echo "$DF" >&6; }
14861 else
14862   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14863 $as_echo "no" >&6; }
14864 fi
14865 
14866 
14867           if test "x$DF" = x; then
14868             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
14869           fi
14870         else
14871           # Otherwise we believe it is a complete path. Use it as it is.
14872           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DF=$tool_specified" >&5
14873 $as_echo "$as_me: Will use user supplied tool DF=$tool_specified" >&6;}
14874           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DF" >&5
14875 $as_echo_n "checking for DF... " >&6; }
14876           if test ! -x "$tool_specified"; then
14877             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
14878 $as_echo "not found" >&6; }
14879             as_fn_error $? "User supplied tool DF=$tool_specified does not exist or is not executable" "$LINENO" 5
14880           fi
14881           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
14882 $as_echo "$tool_specified" >&6; }
14883         fi
14884       fi
14885     fi
14886 
14887   fi
14888 
14889 
14890 
14891 
14892   # Publish this variable in the help.
14893 
14894 
14895   if [ -z "${CPIO+x}" ]; then
14896     # The variable is not set by user, try to locate tool using the code snippet
14897     for ac_prog in cpio bsdcpio
14898 do
14899   # Extract the first word of "$ac_prog", so it can be a program name with args.
14900 set dummy $ac_prog; ac_word=$2
14901 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14902 $as_echo_n "checking for $ac_word... " >&6; }
14903 if ${ac_cv_path_CPIO+:} false; then :
14904   $as_echo_n "(cached) " >&6
14905 else
14906   case $CPIO in
14907   [\\/]* | ?:[\\/]*)
14908   ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
14909   ;;
14910   *)
14911   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14912 for as_dir in $PATH
14913 do
14914   IFS=$as_save_IFS
14915   test -z "$as_dir" && as_dir=.
14916     for ac_exec_ext in '' $ac_executable_extensions; do
14917   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14918     ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
14919     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14920     break 2
14921   fi
14922 done
14923   done
14924 IFS=$as_save_IFS
14925 
14926   ;;
14927 esac
14928 fi
14929 CPIO=$ac_cv_path_CPIO
14930 if test -n "$CPIO"; then
14931   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
14932 $as_echo "$CPIO" >&6; }
14933 else
14934   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14935 $as_echo "no" >&6; }
14936 fi
14937 
14938 
14939   test -n "$CPIO" && break
14940 done
14941 
14942   else
14943     # The variable is set, but is it from the command line or the environment?
14944 
14945     # Try to remove the string !CPIO! from our list.
14946     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CPIO!/}
14947     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
14948       # If it failed, the variable was not from the command line. Ignore it,
14949       # but warn the user (except for BASH, which is always set by the calling BASH).
14950       if test "xCPIO" != xBASH; then
14951         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CPIO from the environment. Use command line variables instead." >&5
14952 $as_echo "$as_me: WARNING: Ignoring value of CPIO from the environment. Use command line variables instead." >&2;}
14953       fi
14954       # Try to locate tool using the code snippet
14955       for ac_prog in cpio bsdcpio
14956 do
14957   # Extract the first word of "$ac_prog", so it can be a program name with args.
14958 set dummy $ac_prog; ac_word=$2
14959 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14960 $as_echo_n "checking for $ac_word... " >&6; }
14961 if ${ac_cv_path_CPIO+:} false; then :
14962   $as_echo_n "(cached) " >&6
14963 else
14964   case $CPIO in
14965   [\\/]* | ?:[\\/]*)
14966   ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
14967   ;;
14968   *)
14969   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14970 for as_dir in $PATH
14971 do
14972   IFS=$as_save_IFS
14973   test -z "$as_dir" && as_dir=.
14974     for ac_exec_ext in '' $ac_executable_extensions; do
14975   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14976     ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
14977     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14978     break 2
14979   fi
14980 done
14981   done
14982 IFS=$as_save_IFS
14983 
14984   ;;
14985 esac
14986 fi
14987 CPIO=$ac_cv_path_CPIO
14988 if test -n "$CPIO"; then
14989   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
14990 $as_echo "$CPIO" >&6; }
14991 else
14992   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14993 $as_echo "no" >&6; }
14994 fi
14995 
14996 
14997   test -n "$CPIO" && break
14998 done
14999 
15000     else
15001       # If it succeeded, then it was overridden by the user. We will use it
15002       # for the tool.
15003 
15004       # First remove it from the list of overridden variables, so we can test
15005       # for unknown variables in the end.
15006       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
15007 
15008       # Check if we try to supply an empty value
15009       if test "x$CPIO" = x; then
15010         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CPIO= (no value)" >&5
15011 $as_echo "$as_me: Setting user supplied tool CPIO= (no value)" >&6;}
15012         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CPIO" >&5
15013 $as_echo_n "checking for CPIO... " >&6; }
15014         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
15015 $as_echo "disabled" >&6; }
15016       else
15017         # Check if the provided tool contains a complete path.
15018         tool_specified="$CPIO"
15019         tool_basename="${tool_specified##*/}"
15020         if test "x$tool_basename" = "x$tool_specified"; then
15021           # A command without a complete path is provided, search $PATH.
15022           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CPIO=$tool_basename" >&5
15023 $as_echo "$as_me: Will search for user supplied tool CPIO=$tool_basename" >&6;}
15024           # Extract the first word of "$tool_basename", so it can be a program name with args.
15025 set dummy $tool_basename; ac_word=$2
15026 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
15027 $as_echo_n "checking for $ac_word... " >&6; }
15028 if ${ac_cv_path_CPIO+:} false; then :
15029   $as_echo_n "(cached) " >&6
15030 else
15031   case $CPIO in
15032   [\\/]* | ?:[\\/]*)
15033   ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
15034   ;;
15035   *)
15036   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
15037 for as_dir in $PATH
15038 do
15039   IFS=$as_save_IFS
15040   test -z "$as_dir" && as_dir=.
15041     for ac_exec_ext in '' $ac_executable_extensions; do
15042   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
15043     ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
15044     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
15045     break 2
15046   fi
15047 done
15048   done
15049 IFS=$as_save_IFS
15050 
15051   ;;
15052 esac
15053 fi
15054 CPIO=$ac_cv_path_CPIO
15055 if test -n "$CPIO"; then
15056   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
15057 $as_echo "$CPIO" >&6; }
15058 else
15059   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
15060 $as_echo "no" >&6; }
15061 fi
15062 
15063 
15064           if test "x$CPIO" = x; then
15065             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
15066           fi
15067         else
15068           # Otherwise we believe it is a complete path. Use it as it is.
15069           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CPIO=$tool_specified" >&5
15070 $as_echo "$as_me: Will use user supplied tool CPIO=$tool_specified" >&6;}
15071           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CPIO" >&5
15072 $as_echo_n "checking for CPIO... " >&6; }
15073           if test ! -x "$tool_specified"; then
15074             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
15075 $as_echo "not found" >&6; }
15076             as_fn_error $? "User supplied tool CPIO=$tool_specified does not exist or is not executable" "$LINENO" 5
15077           fi
15078           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
15079 $as_echo "$tool_specified" >&6; }
15080         fi
15081       fi
15082     fi
15083 
15084   fi
15085 
15086 
15087 
15088 
15089   # Publish this variable in the help.
15090 
15091 
15092   if [ -z "${NICE+x}" ]; then
15093     # The variable is not set by user, try to locate tool using the code snippet
15094     for ac_prog in nice
15095 do
15096   # Extract the first word of "$ac_prog", so it can be a program name with args.
15097 set dummy $ac_prog; ac_word=$2
15098 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
15099 $as_echo_n "checking for $ac_word... " >&6; }
15100 if ${ac_cv_path_NICE+:} false; then :
15101   $as_echo_n "(cached) " >&6
15102 else
15103   case $NICE in
15104   [\\/]* | ?:[\\/]*)
15105   ac_cv_path_NICE="$NICE" # Let the user override the test with a path.
15106   ;;
15107   *)
15108   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
15109 for as_dir in $PATH
15110 do
15111   IFS=$as_save_IFS
15112   test -z "$as_dir" && as_dir=.
15113     for ac_exec_ext in '' $ac_executable_extensions; do
15114   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
15115     ac_cv_path_NICE="$as_dir/$ac_word$ac_exec_ext"
15116     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
15117     break 2
15118   fi
15119 done
15120   done
15121 IFS=$as_save_IFS
15122 
15123   ;;
15124 esac
15125 fi
15126 NICE=$ac_cv_path_NICE
15127 if test -n "$NICE"; then
15128   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NICE" >&5
15129 $as_echo "$NICE" >&6; }
15130 else
15131   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
15132 $as_echo "no" >&6; }
15133 fi
15134 
15135 
15136   test -n "$NICE" && break
15137 done
15138 
15139   else
15140     # The variable is set, but is it from the command line or the environment?
15141 
15142     # Try to remove the string !NICE! from our list.
15143     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!NICE!/}
15144     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
15145       # If it failed, the variable was not from the command line. Ignore it,
15146       # but warn the user (except for BASH, which is always set by the calling BASH).
15147       if test "xNICE" != xBASH; then
15148         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of NICE from the environment. Use command line variables instead." >&5
15149 $as_echo "$as_me: WARNING: Ignoring value of NICE from the environment. Use command line variables instead." >&2;}
15150       fi
15151       # Try to locate tool using the code snippet
15152       for ac_prog in nice
15153 do
15154   # Extract the first word of "$ac_prog", so it can be a program name with args.
15155 set dummy $ac_prog; ac_word=$2
15156 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
15157 $as_echo_n "checking for $ac_word... " >&6; }
15158 if ${ac_cv_path_NICE+:} false; then :
15159   $as_echo_n "(cached) " >&6
15160 else
15161   case $NICE in
15162   [\\/]* | ?:[\\/]*)
15163   ac_cv_path_NICE="$NICE" # Let the user override the test with a path.
15164   ;;
15165   *)
15166   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
15167 for as_dir in $PATH
15168 do
15169   IFS=$as_save_IFS
15170   test -z "$as_dir" && as_dir=.
15171     for ac_exec_ext in '' $ac_executable_extensions; do
15172   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
15173     ac_cv_path_NICE="$as_dir/$ac_word$ac_exec_ext"
15174     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
15175     break 2
15176   fi
15177 done
15178   done
15179 IFS=$as_save_IFS
15180 
15181   ;;
15182 esac
15183 fi
15184 NICE=$ac_cv_path_NICE
15185 if test -n "$NICE"; then
15186   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NICE" >&5
15187 $as_echo "$NICE" >&6; }
15188 else
15189   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
15190 $as_echo "no" >&6; }
15191 fi
15192 
15193 
15194   test -n "$NICE" && break
15195 done
15196 
15197     else
15198       # If it succeeded, then it was overridden by the user. We will use it
15199       # for the tool.
15200 
15201       # First remove it from the list of overridden variables, so we can test
15202       # for unknown variables in the end.
15203       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
15204 
15205       # Check if we try to supply an empty value
15206       if test "x$NICE" = x; then
15207         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool NICE= (no value)" >&5
15208 $as_echo "$as_me: Setting user supplied tool NICE= (no value)" >&6;}
15209         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NICE" >&5
15210 $as_echo_n "checking for NICE... " >&6; }
15211         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
15212 $as_echo "disabled" >&6; }
15213       else
15214         # Check if the provided tool contains a complete path.
15215         tool_specified="$NICE"
15216         tool_basename="${tool_specified##*/}"
15217         if test "x$tool_basename" = "x$tool_specified"; then
15218           # A command without a complete path is provided, search $PATH.
15219           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool NICE=$tool_basename" >&5
15220 $as_echo "$as_me: Will search for user supplied tool NICE=$tool_basename" >&6;}
15221           # Extract the first word of "$tool_basename", so it can be a program name with args.
15222 set dummy $tool_basename; ac_word=$2
15223 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
15224 $as_echo_n "checking for $ac_word... " >&6; }
15225 if ${ac_cv_path_NICE+:} false; then :
15226   $as_echo_n "(cached) " >&6
15227 else
15228   case $NICE in
15229   [\\/]* | ?:[\\/]*)
15230   ac_cv_path_NICE="$NICE" # Let the user override the test with a path.
15231   ;;
15232   *)
15233   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
15234 for as_dir in $PATH
15235 do
15236   IFS=$as_save_IFS
15237   test -z "$as_dir" && as_dir=.
15238     for ac_exec_ext in '' $ac_executable_extensions; do
15239   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
15240     ac_cv_path_NICE="$as_dir/$ac_word$ac_exec_ext"
15241     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
15242     break 2
15243   fi
15244 done
15245   done
15246 IFS=$as_save_IFS
15247 
15248   ;;
15249 esac
15250 fi
15251 NICE=$ac_cv_path_NICE
15252 if test -n "$NICE"; then
15253   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NICE" >&5
15254 $as_echo "$NICE" >&6; }
15255 else
15256   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
15257 $as_echo "no" >&6; }
15258 fi
15259 
15260 
15261           if test "x$NICE" = x; then
15262             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
15263           fi
15264         else
15265           # Otherwise we believe it is a complete path. Use it as it is.
15266           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool NICE=$tool_specified" >&5
15267 $as_echo "$as_me: Will use user supplied tool NICE=$tool_specified" >&6;}
15268           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NICE" >&5
15269 $as_echo_n "checking for NICE... " >&6; }
15270           if test ! -x "$tool_specified"; then
15271             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
15272 $as_echo "not found" >&6; }
15273             as_fn_error $? "User supplied tool NICE=$tool_specified does not exist or is not executable" "$LINENO" 5
15274           fi
15275           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
15276 $as_echo "$tool_specified" >&6; }
15277         fi
15278       fi
15279     fi
15280 
15281   fi
15282 
15283 
15284 
15285 
15286 # Now we can determine OpenJDK build and target platforms. This is required to
15287 # have early on.
15288 # Make sure we can run config.sub.
15289 $SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
15290   as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5
15291 
15292 { $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
15293 $as_echo_n "checking build system type... " >&6; }
15294 if ${ac_cv_build+:} false; then :
15295   $as_echo_n "(cached) " >&6
15296 else
15297   ac_build_alias=$build_alias
15298 test "x$ac_build_alias" = x &&
15299   ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
15300 test "x$ac_build_alias" = x &&
15301   as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5
15302 ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
15303   as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5
15304 
15305 fi
15306 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
15307 $as_echo "$ac_cv_build" >&6; }
15308 case $ac_cv_build in
15309 *-*-*) ;;
15310 *) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;;
15311 esac
15312 build=$ac_cv_build
15313 ac_save_IFS=$IFS; IFS='-'
15314 set x $ac_cv_build
15315 shift
15316 build_cpu=$1
15317 build_vendor=$2
15318 shift; shift
15319 # Remember, the first character of IFS is used to create $*,
15320 # except with old shells:
15321 build_os=$*
15322 IFS=$ac_save_IFS
15323 case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
15324 
15325 
15326 { $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
15327 $as_echo_n "checking host system type... " >&6; }
15328 if ${ac_cv_host+:} false; then :
15329   $as_echo_n "(cached) " >&6
15330 else
15331   if test "x$host_alias" = x; then
15332   ac_cv_host=$ac_cv_build
15333 else
15334   ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
15335     as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5
15336 fi
15337 
15338 fi
15339 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
15340 $as_echo "$ac_cv_host" >&6; }
15341 case $ac_cv_host in
15342 *-*-*) ;;
15343 *) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;;
15344 esac
15345 host=$ac_cv_host
15346 ac_save_IFS=$IFS; IFS='-'
15347 set x $ac_cv_host
15348 shift
15349 host_cpu=$1
15350 host_vendor=$2
15351 shift; shift
15352 # Remember, the first character of IFS is used to create $*,
15353 # except with old shells:
15354 host_os=$*
15355 IFS=$ac_save_IFS
15356 case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
15357 
15358 
15359 { $as_echo "$as_me:${as_lineno-$LINENO}: checking target system type" >&5
15360 $as_echo_n "checking target system type... " >&6; }
15361 if ${ac_cv_target+:} false; then :
15362   $as_echo_n "(cached) " >&6
15363 else
15364   if test "x$target_alias" = x; then
15365   ac_cv_target=$ac_cv_host
15366 else
15367   ac_cv_target=`$SHELL "$ac_aux_dir/config.sub" $target_alias` ||
15368     as_fn_error $? "$SHELL $ac_aux_dir/config.sub $target_alias failed" "$LINENO" 5
15369 fi
15370 
15371 fi
15372 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_target" >&5
15373 $as_echo "$ac_cv_target" >&6; }
15374 case $ac_cv_target in
15375 *-*-*) ;;
15376 *) as_fn_error $? "invalid value of canonical target" "$LINENO" 5;;
15377 esac
15378 target=$ac_cv_target
15379 ac_save_IFS=$IFS; IFS='-'
15380 set x $ac_cv_target
15381 shift
15382 target_cpu=$1
15383 target_vendor=$2
15384 shift; shift
15385 # Remember, the first character of IFS is used to create $*,
15386 # except with old shells:
15387 target_os=$*
15388 IFS=$ac_save_IFS
15389 case $target_os in *\ *) target_os=`echo "$target_os" | sed 's/ /-/g'`;; esac
15390 
15391 
15392 # The aliases save the names the user supplied, while $host etc.
15393 # will get canonicalized.
15394 test -n "$target_alias" &&
15395   test "$program_prefix$program_suffix$program_transform_name" = \
15396     NONENONEs,x,x, &&
15397   program_prefix=${target_alias}-
15398 
15399   # Figure out the build and target systems. # Note that in autoconf terminology, "build" is obvious, but "target"
15400   # is confusing; it assumes you are cross-compiling a cross-compiler (!)  and "target" is thus the target of the
15401   # product you're building. The target of this build is called "host". Since this is confusing to most people, we
15402   # have not adopted that system, but use "target" as the platform we are building for. In some places though we need
15403   # to use the configure naming style.
15404 
15405 
15406 
15407 
15408 
15409   # Copy the autoconf trip/quadruplet verbatim to OPENJDK_TARGET_AUTOCONF_NAME
15410   # (from the autoconf "host") and OPENJDK_BUILD_AUTOCONF_NAME
15411   # Note that we might later on rewrite e.g. OPENJDK_TARGET_CPU due to reduced build,
15412   # but this will not change the value of OPENJDK_TARGET_AUTOCONF_NAME.
15413   OPENJDK_TARGET_AUTOCONF_NAME="$host"
15414   OPENJDK_BUILD_AUTOCONF_NAME="$build"
15415 
15416 
15417 
15418   # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
15419 
15420   case "$build_os" in
15421     *linux*)
15422       VAR_OS=linux
15423       VAR_OS_TYPE=unix
15424       ;;
15425     *solaris*)
15426       VAR_OS=solaris
15427       VAR_OS_TYPE=unix
15428       ;;
15429     *darwin*)
15430       VAR_OS=macosx
15431       VAR_OS_TYPE=unix
15432       ;;
15433     *bsd*)
15434       VAR_OS=bsd
15435       VAR_OS_TYPE=unix
15436       ;;
15437     *cygwin*)
15438       VAR_OS=windows
15439       VAR_OS_ENV=windows.cygwin
15440       ;;
15441     *mingw*)
15442       VAR_OS=windows
15443       VAR_OS_ENV=windows.msys
15444       ;;
15445     *aix*)
15446       VAR_OS=aix
15447       VAR_OS_TYPE=unix
15448       ;;
15449     *)
15450       as_fn_error $? "unsupported operating system $build_os" "$LINENO" 5
15451       ;;
15452   esac
15453 
15454 
15455   # First argument is the cpu name from the trip/quad
15456   case "$build_cpu" in
15457     x86_64)
15458       VAR_CPU=x86_64
15459       VAR_CPU_ARCH=x86
15460       VAR_CPU_BITS=64
15461       VAR_CPU_ENDIAN=little
15462       ;;
15463     i?86)
15464       VAR_CPU=x86
15465       VAR_CPU_ARCH=x86
15466       VAR_CPU_BITS=32
15467       VAR_CPU_ENDIAN=little
15468       ;;
15469     arm*)
15470       VAR_CPU=arm
15471       VAR_CPU_ARCH=arm
15472       VAR_CPU_BITS=32
15473       VAR_CPU_ENDIAN=little
15474       ;;
15475     aarch64)
15476       VAR_CPU=aarch64
15477       VAR_CPU_ARCH=aarch64
15478       VAR_CPU_BITS=64
15479       VAR_CPU_ENDIAN=little
15480       ;;
15481     powerpc)
15482       VAR_CPU=ppc
15483       VAR_CPU_ARCH=ppc
15484       VAR_CPU_BITS=32
15485       VAR_CPU_ENDIAN=big
15486       ;;
15487     powerpc64)
15488       VAR_CPU=ppc64
15489       VAR_CPU_ARCH=ppc
15490       VAR_CPU_BITS=64
15491       VAR_CPU_ENDIAN=big
15492       ;;
15493     powerpc64le)
15494       VAR_CPU=ppc64le
15495       VAR_CPU_ARCH=ppc
15496       VAR_CPU_BITS=64
15497       VAR_CPU_ENDIAN=little
15498       ;;
15499     s390)
15500       VAR_CPU=s390
15501       VAR_CPU_ARCH=s390
15502       VAR_CPU_BITS=32
15503       VAR_CPU_ENDIAN=big
15504       ;;
15505     s390x)
15506       VAR_CPU=s390x
15507       VAR_CPU_ARCH=s390
15508       VAR_CPU_BITS=64
15509       VAR_CPU_ENDIAN=big
15510       ;;
15511     sparc)
15512       VAR_CPU=sparc
15513       VAR_CPU_ARCH=sparc
15514       VAR_CPU_BITS=32
15515       VAR_CPU_ENDIAN=big
15516       ;;
15517     sparcv9|sparc64)
15518       VAR_CPU=sparcv9
15519       VAR_CPU_ARCH=sparc
15520       VAR_CPU_BITS=64
15521       VAR_CPU_ENDIAN=big
15522       ;;
15523     *)
15524       as_fn_error $? "unsupported cpu $build_cpu" "$LINENO" 5
15525       ;;
15526   esac
15527 
15528   # ..and setup our own variables. (Do this explicitely to facilitate searching)
15529   OPENJDK_BUILD_OS="$VAR_OS"
15530   if test "x$VAR_OS_TYPE" != x; then
15531     OPENJDK_BUILD_OS_TYPE="$VAR_OS_TYPE"
15532   else
15533     OPENJDK_BUILD_OS_TYPE="$VAR_OS"
15534   fi
15535   if test "x$VAR_OS_ENV" != x; then
15536     OPENJDK_BUILD_OS_ENV="$VAR_OS_ENV"
15537   else
15538     OPENJDK_BUILD_OS_ENV="$VAR_OS"
15539   fi
15540   OPENJDK_BUILD_CPU="$VAR_CPU"
15541   OPENJDK_BUILD_CPU_ARCH="$VAR_CPU_ARCH"
15542   OPENJDK_BUILD_CPU_BITS="$VAR_CPU_BITS"
15543   OPENJDK_BUILD_CPU_ENDIAN="$VAR_CPU_ENDIAN"
15544 
15545 
15546 
15547 
15548 
15549 
15550 
15551 
15552   { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-build os-cpu" >&5
15553 $as_echo_n "checking openjdk-build os-cpu... " >&6; }
15554   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&5
15555 $as_echo "$OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&6; }
15556 
15557   # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
15558 
15559   case "$host_os" in
15560     *linux*)
15561       VAR_OS=linux
15562       VAR_OS_TYPE=unix
15563       ;;
15564     *solaris*)
15565       VAR_OS=solaris
15566       VAR_OS_TYPE=unix
15567       ;;
15568     *darwin*)
15569       VAR_OS=macosx
15570       VAR_OS_TYPE=unix
15571       ;;
15572     *bsd*)
15573       VAR_OS=bsd
15574       VAR_OS_TYPE=unix
15575       ;;
15576     *cygwin*)
15577       VAR_OS=windows
15578       VAR_OS_ENV=windows.cygwin
15579       ;;
15580     *mingw*)
15581       VAR_OS=windows
15582       VAR_OS_ENV=windows.msys
15583       ;;
15584     *aix*)
15585       VAR_OS=aix
15586       VAR_OS_TYPE=unix
15587       ;;
15588     *)
15589       as_fn_error $? "unsupported operating system $host_os" "$LINENO" 5
15590       ;;
15591   esac
15592 
15593 
15594   # First argument is the cpu name from the trip/quad
15595   case "$host_cpu" in
15596     x86_64)
15597       VAR_CPU=x86_64
15598       VAR_CPU_ARCH=x86
15599       VAR_CPU_BITS=64
15600       VAR_CPU_ENDIAN=little
15601       ;;
15602     i?86)
15603       VAR_CPU=x86
15604       VAR_CPU_ARCH=x86
15605       VAR_CPU_BITS=32
15606       VAR_CPU_ENDIAN=little
15607       ;;
15608     arm*)
15609       VAR_CPU=arm
15610       VAR_CPU_ARCH=arm
15611       VAR_CPU_BITS=32
15612       VAR_CPU_ENDIAN=little
15613       ;;
15614     aarch64)
15615       VAR_CPU=aarch64
15616       VAR_CPU_ARCH=aarch64
15617       VAR_CPU_BITS=64
15618       VAR_CPU_ENDIAN=little
15619       ;;
15620     powerpc)
15621       VAR_CPU=ppc
15622       VAR_CPU_ARCH=ppc
15623       VAR_CPU_BITS=32
15624       VAR_CPU_ENDIAN=big
15625       ;;
15626     powerpc64)
15627       VAR_CPU=ppc64
15628       VAR_CPU_ARCH=ppc
15629       VAR_CPU_BITS=64
15630       VAR_CPU_ENDIAN=big
15631       ;;
15632     powerpc64le)
15633       VAR_CPU=ppc64le
15634       VAR_CPU_ARCH=ppc
15635       VAR_CPU_BITS=64
15636       VAR_CPU_ENDIAN=little
15637       ;;
15638     s390)
15639       VAR_CPU=s390
15640       VAR_CPU_ARCH=s390
15641       VAR_CPU_BITS=32
15642       VAR_CPU_ENDIAN=big
15643       ;;
15644     s390x)
15645       VAR_CPU=s390x
15646       VAR_CPU_ARCH=s390
15647       VAR_CPU_BITS=64
15648       VAR_CPU_ENDIAN=big
15649       ;;
15650     sparc)
15651       VAR_CPU=sparc
15652       VAR_CPU_ARCH=sparc
15653       VAR_CPU_BITS=32
15654       VAR_CPU_ENDIAN=big
15655       ;;
15656     sparcv9|sparc64)
15657       VAR_CPU=sparcv9
15658       VAR_CPU_ARCH=sparc
15659       VAR_CPU_BITS=64
15660       VAR_CPU_ENDIAN=big
15661       ;;
15662     *)
15663       as_fn_error $? "unsupported cpu $host_cpu" "$LINENO" 5
15664       ;;
15665   esac
15666 
15667   # ... and setup our own variables. (Do this explicitely to facilitate searching)
15668   OPENJDK_TARGET_OS="$VAR_OS"
15669   if test "x$VAR_OS_TYPE" != x; then
15670     OPENJDK_TARGET_OS_TYPE="$VAR_OS_TYPE"
15671   else
15672     OPENJDK_TARGET_OS_TYPE="$VAR_OS"
15673   fi
15674   if test "x$VAR_OS_ENV" != x; then
15675     OPENJDK_TARGET_OS_ENV="$VAR_OS_ENV"
15676   else
15677     OPENJDK_TARGET_OS_ENV="$VAR_OS"
15678   fi
15679   OPENJDK_TARGET_CPU="$VAR_CPU"
15680   OPENJDK_TARGET_CPU_ARCH="$VAR_CPU_ARCH"
15681   OPENJDK_TARGET_CPU_BITS="$VAR_CPU_BITS"
15682   OPENJDK_TARGET_CPU_ENDIAN="$VAR_CPU_ENDIAN"
15683 
15684 
15685 
15686 
15687 
15688 
15689 
15690 
15691   { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-target os-cpu" >&5
15692 $as_echo_n "checking openjdk-target os-cpu... " >&6; }
15693   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&5
15694 $as_echo "$OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&6; }
15695 
15696 
15697 
15698 # Check whether --with-target-bits was given.
15699 if test "${with_target_bits+set}" = set; then :
15700   withval=$with_target_bits;
15701 fi
15702 
15703 
15704   # We have three types of compiles:
15705   # native  == normal compilation, target system == build system
15706   # cross   == traditional cross compilation, target system != build system; special toolchain needed
15707   # reduced == using native compilers, but with special flags (e.g. -m32) to produce 32-bit builds on 64-bit machines
15708   #
15709   if test "x$OPENJDK_BUILD_AUTOCONF_NAME" != "x$OPENJDK_TARGET_AUTOCONF_NAME"; then
15710     # We're doing a proper cross-compilation
15711     COMPILE_TYPE="cross"
15712   else
15713     COMPILE_TYPE="native"
15714   fi
15715 
15716   if test "x$with_target_bits" != x; then
15717     if test "x$COMPILE_TYPE" = "xcross"; then
15718       as_fn_error $? "It is not possible to combine --with-target-bits=X and proper cross-compilation. Choose either." "$LINENO" 5
15719     fi
15720 
15721     if test "x$with_target_bits" = x32 && test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
15722       # A reduced build is requested
15723       COMPILE_TYPE="reduced"
15724       OPENJDK_TARGET_CPU_BITS=32
15725       if test "x$OPENJDK_TARGET_CPU_ARCH" = "xx86"; then
15726         OPENJDK_TARGET_CPU=x86
15727       elif test "x$OPENJDK_TARGET_CPU_ARCH" = "xsparc"; then
15728         OPENJDK_TARGET_CPU=sparc
15729       else
15730         as_fn_error $? "Reduced build (--with-target-bits=32) is only supported on x86_64 and sparcv9" "$LINENO" 5
15731       fi
15732     elif test "x$with_target_bits" = x64 && test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
15733       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
15734     elif test "x$with_target_bits" = "x$OPENJDK_TARGET_CPU_BITS"; then
15735       { $as_echo "$as_me:${as_lineno-$LINENO}: --with-target-bits are set to build platform address size; argument has no meaning" >&5
15736 $as_echo "$as_me: --with-target-bits are set to build platform address size; argument has no meaning" >&6;}
15737     else
15738       as_fn_error $? "--with-target-bits can only be 32 or 64, you specified $with_target_bits!" "$LINENO" 5
15739     fi
15740   fi
15741 
15742 
15743   { $as_echo "$as_me:${as_lineno-$LINENO}: checking compilation type" >&5
15744 $as_echo_n "checking compilation type... " >&6; }
15745   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMPILE_TYPE" >&5
15746 $as_echo "$COMPILE_TYPE" >&6; }
15747 
15748 
15749   if test "x$OPENJDK_TARGET_OS" = "xsolaris"; then
15750     REQUIRED_OS_NAME=SunOS
15751     REQUIRED_OS_VERSION=5.10
15752   fi
15753   if test "x$OPENJDK_TARGET_OS" = "xlinux"; then
15754     REQUIRED_OS_NAME=Linux
15755     REQUIRED_OS_VERSION=2.6
15756   fi
15757   if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
15758     REQUIRED_OS_NAME=Windows
15759     if test "x$OPENJDK_TARGET_CPU_BITS" = "x64"; then
15760       REQUIRED_OS_VERSION=5.2
15761     else
15762       REQUIRED_OS_VERSION=5.1
15763     fi
15764   fi
15765   if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
15766     REQUIRED_OS_NAME=Darwin
15767     REQUIRED_OS_VERSION=11.2
15768   fi
15769   if test "x$OPENJDK_TARGET_OS" = "xaix"; then
15770     REQUIRED_OS_NAME=AIX
15771     REQUIRED_OS_VERSION=7.1
15772   fi
15773 
15774 
15775 
15776 
15777 
15778 
15779   # Also store the legacy naming of the cpu.
15780   # Ie i586 and amd64 instead of x86 and x86_64
15781   OPENJDK_TARGET_CPU_LEGACY="$OPENJDK_TARGET_CPU"
15782   if test "x$OPENJDK_TARGET_CPU" = xx86; then
15783     OPENJDK_TARGET_CPU_LEGACY="i586"
15784   elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
15785     # On all platforms except MacOSX replace x86_64 with amd64.
15786     OPENJDK_TARGET_CPU_LEGACY="amd64"
15787   fi
15788 
15789 
15790   # And the second legacy naming of the cpu.
15791   # Ie i386 and amd64 instead of x86 and x86_64.
15792   OPENJDK_TARGET_CPU_LEGACY_LIB="$OPENJDK_TARGET_CPU"
15793   if test "x$OPENJDK_TARGET_CPU" = xx86; then
15794     OPENJDK_TARGET_CPU_LEGACY_LIB="i386"
15795   elif test "x$OPENJDK_TARGET_CPU" = xx86_64; then
15796     OPENJDK_TARGET_CPU_LEGACY_LIB="amd64"
15797   fi
15798 
15799 
15800   # This is the name of the cpu (but using i386 and amd64 instead of
15801   # x86 and x86_64, respectively), preceeded by a /, to be used when
15802   # locating libraries. On macosx, it's empty, though.
15803   OPENJDK_TARGET_CPU_LIBDIR="/$OPENJDK_TARGET_CPU_LEGACY_LIB"
15804   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
15805     OPENJDK_TARGET_CPU_LIBDIR=""
15806   fi
15807 
15808 
15809   # OPENJDK_TARGET_CPU_ISADIR is normally empty. On 64-bit Solaris systems, it is set to
15810   # /amd64 or /sparcv9. This string is appended to some library paths, like this:
15811   # /usr/lib${OPENJDK_TARGET_CPU_ISADIR}/libexample.so
15812   OPENJDK_TARGET_CPU_ISADIR=""
15813   if test "x$OPENJDK_TARGET_OS" = xsolaris; then
15814     if test "x$OPENJDK_TARGET_CPU" = xx86_64; then
15815       OPENJDK_TARGET_CPU_ISADIR="/amd64"
15816     elif test "x$OPENJDK_TARGET_CPU" = xsparcv9; then
15817       OPENJDK_TARGET_CPU_ISADIR="/sparcv9"
15818     fi
15819   fi
15820 
15821 
15822   # Setup OPENJDK_TARGET_CPU_OSARCH, which is used to set the os.arch Java system property
15823   OPENJDK_TARGET_CPU_OSARCH="$OPENJDK_TARGET_CPU"
15824   if test "x$OPENJDK_TARGET_OS" = xlinux && test "x$OPENJDK_TARGET_CPU" = xx86; then
15825     # On linux only, we replace x86 with i386.
15826     OPENJDK_TARGET_CPU_OSARCH="i386"
15827   elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
15828     # On all platforms except macosx, we replace x86_64 with amd64.
15829     OPENJDK_TARGET_CPU_OSARCH="amd64"
15830   fi
15831 
15832 
15833   OPENJDK_TARGET_CPU_JLI="$OPENJDK_TARGET_CPU"
15834   if test "x$OPENJDK_TARGET_CPU" = xx86; then
15835     OPENJDK_TARGET_CPU_JLI="i386"
15836   elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
15837     # On all platforms except macosx, we replace x86_64 with amd64.
15838     OPENJDK_TARGET_CPU_JLI="amd64"
15839   fi
15840   # Now setup the -D flags for building libjli.
15841   OPENJDK_TARGET_CPU_JLI_CFLAGS="-DLIBARCHNAME='\"$OPENJDK_TARGET_CPU_JLI\"'"
15842   if test "x$OPENJDK_TARGET_OS" = xsolaris; then
15843     if test "x$OPENJDK_TARGET_CPU_ARCH" = xsparc; then
15844       OPENJDK_TARGET_CPU_JLI_CFLAGS="$OPENJDK_TARGET_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"sparc\"' -DLIBARCH64NAME='\"sparcv9\"'"
15845     elif test "x$OPENJDK_TARGET_CPU_ARCH" = xx86; then
15846       OPENJDK_TARGET_CPU_JLI_CFLAGS="$OPENJDK_TARGET_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"i386\"' -DLIBARCH64NAME='\"amd64\"'"
15847     fi
15848   fi
15849 
15850 
15851   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
15852       OPENJDK_TARGET_OS_EXPORT_DIR=macosx
15853   else
15854       OPENJDK_TARGET_OS_EXPORT_DIR=${OPENJDK_TARGET_OS_TYPE}
15855   fi
15856 
15857 
15858   # The new version string in JDK 9 also defined new naming of OS and ARCH for bundles
15859   # Macosx is osx and x86_64 is x64
15860   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
15861     OPENJDK_TARGET_OS_BUNDLE="osx"
15862   else
15863     OPENJDK_TARGET_OS_BUNDLE="$OPENJDK_TARGET_OS"
15864   fi
15865   if test "x$OPENJDK_TARGET_CPU" = xx86_64; then
15866     OPENJDK_TARGET_CPU_BUNDLE="x64"
15867   else
15868     OPENJDK_TARGET_CPU_BUNDLE="$OPENJDK_TARGET_CPU"
15869   fi
15870   OPENJDK_TARGET_BUNDLE_PLATFORM="${OPENJDK_TARGET_OS_BUNDLE}-${OPENJDK_TARGET_CPU_BUNDLE}"
15871 
15872 
15873 
15874 
15875   if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
15876     A_LP64="LP64:="
15877     # -D_LP64=1 is only set on linux and mac. Setting on windows causes diff in
15878     # unpack200.exe
15879     if test "x$OPENJDK_TARGET_OS" = xlinux || test "x$OPENJDK_TARGET_OS" = xmacosx; then
15880       OPENJDK_TARGET_ADD_LP64="-D_LP64=1"
15881     fi
15882   fi
15883   LP64=$A_LP64
15884 
15885 
15886   if test "x$COMPILE_TYPE" = "xcross"; then
15887     # FIXME: ... or should this include reduced builds..?
15888     DEFINE_CROSS_COMPILE_ARCH="CROSS_COMPILE_ARCH:=$OPENJDK_TARGET_CPU_LEGACY"
15889   else
15890     DEFINE_CROSS_COMPILE_ARCH=""
15891   fi
15892 
15893 
15894   # Convert openjdk platform names to hotspot names
15895 
15896   HOTSPOT_TARGET_OS=${OPENJDK_TARGET_OS}
15897   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
15898     HOTSPOT_TARGET_OS=bsd
15899   fi
15900 
15901 
15902   HOTSPOT_TARGET_OS_TYPE=${OPENJDK_TARGET_OS_TYPE}
15903   if test "x$OPENJDK_TARGET_OS_TYPE" = xunix; then
15904     HOTSPOT_TARGET_OS_TYPE=posix
15905   fi
15906 
15907 
15908   HOTSPOT_TARGET_CPU=${OPENJDK_TARGET_CPU}
15909   if test "x$OPENJDK_TARGET_CPU" = xx86; then
15910     HOTSPOT_TARGET_CPU=x86_32
15911   elif test "x$OPENJDK_TARGET_CPU" = xsparcv9; then
15912     HOTSPOT_TARGET_CPU=sparc
15913   elif test "x$OPENJDK_TARGET_CPU" = xppc64; then
15914     HOTSPOT_TARGET_CPU=ppc_64
15915   elif test "x$OPENJDK_TARGET_CPU" = xppc64le; then
15916     HOTSPOT_TARGET_CPU=ppc_64
15917   fi
15918 
15919 
15920   # This is identical with OPENJDK_*, but define anyway for consistency.
15921   HOTSPOT_TARGET_CPU_ARCH=${OPENJDK_TARGET_CPU_ARCH}
15922 
15923 
15924   # Setup HOTSPOT_TARGET_CPU_DEFINE
15925   if test "x$OPENJDK_TARGET_CPU" = xx86; then
15926     HOTSPOT_TARGET_CPU_DEFINE=IA32
15927   elif test "x$OPENJDK_TARGET_CPU" = xx86_64; then
15928     HOTSPOT_TARGET_CPU_DEFINE=AMD64
15929   elif test "x$OPENJDK_TARGET_CPU" = xsparcv9; then
15930     HOTSPOT_TARGET_CPU_DEFINE=SPARC
15931   elif test "x$OPENJDK_TARGET_CPU" = xaarch64; then
15932     HOTSPOT_TARGET_CPU_DEFINE=AARCH64
15933   elif test "x$OPENJDK_TARGET_CPU" = xppc64; then
15934     HOTSPOT_TARGET_CPU_DEFINE=PPC64
15935   elif test "x$OPENJDK_TARGET_CPU" = xppc64le; then
15936     HOTSPOT_TARGET_CPU_DEFINE=PPC64
15937 
15938   # The cpu defines below are for zero, we don't support them directly.
15939   elif test "x$OPENJDK_TARGET_CPU" = xsparc; then
15940     HOTSPOT_TARGET_CPU_DEFINE=SPARC
15941   elif test "x$OPENJDK_TARGET_CPU" = xppc; then
15942     HOTSPOT_TARGET_CPU_DEFINE=PPC32
15943   elif test "x$OPENJDK_TARGET_CPU" = xs390; then
15944     HOTSPOT_TARGET_CPU_DEFINE=S390
15945   elif test "x$OPENJDK_TARGET_CPU" = xs390x; then
15946     HOTSPOT_TARGET_CPU_DEFINE=S390
15947   fi
15948 
15949 
15950 
15951 
15952   # Also store the legacy naming of the cpu.
15953   # Ie i586 and amd64 instead of x86 and x86_64
15954   OPENJDK_BUILD_CPU_LEGACY="$OPENJDK_BUILD_CPU"
15955   if test "x$OPENJDK_BUILD_CPU" = xx86; then
15956     OPENJDK_BUILD_CPU_LEGACY="i586"
15957   elif test "x$OPENJDK_BUILD_OS" != xmacosx && test "x$OPENJDK_BUILD_CPU" = xx86_64; then
15958     # On all platforms except MacOSX replace x86_64 with amd64.
15959     OPENJDK_BUILD_CPU_LEGACY="amd64"
15960   fi
15961 
15962 
15963   # And the second legacy naming of the cpu.
15964   # Ie i386 and amd64 instead of x86 and x86_64.
15965   OPENJDK_BUILD_CPU_LEGACY_LIB="$OPENJDK_BUILD_CPU"
15966   if test "x$OPENJDK_BUILD_CPU" = xx86; then
15967     OPENJDK_BUILD_CPU_LEGACY_LIB="i386"
15968   elif test "x$OPENJDK_BUILD_CPU" = xx86_64; then
15969     OPENJDK_BUILD_CPU_LEGACY_LIB="amd64"
15970   fi
15971 
15972 
15973   # This is the name of the cpu (but using i386 and amd64 instead of
15974   # x86 and x86_64, respectively), preceeded by a /, to be used when
15975   # locating libraries. On macosx, it's empty, though.
15976   OPENJDK_BUILD_CPU_LIBDIR="/$OPENJDK_BUILD_CPU_LEGACY_LIB"
15977   if test "x$OPENJDK_BUILD_OS" = xmacosx; then
15978     OPENJDK_BUILD_CPU_LIBDIR=""
15979   fi
15980 
15981 
15982   # OPENJDK_BUILD_CPU_ISADIR is normally empty. On 64-bit Solaris systems, it is set to
15983   # /amd64 or /sparcv9. This string is appended to some library paths, like this:
15984   # /usr/lib${OPENJDK_BUILD_CPU_ISADIR}/libexample.so
15985   OPENJDK_BUILD_CPU_ISADIR=""
15986   if test "x$OPENJDK_BUILD_OS" = xsolaris; then
15987     if test "x$OPENJDK_BUILD_CPU" = xx86_64; then
15988       OPENJDK_BUILD_CPU_ISADIR="/amd64"
15989     elif test "x$OPENJDK_BUILD_CPU" = xsparcv9; then
15990       OPENJDK_BUILD_CPU_ISADIR="/sparcv9"
15991     fi
15992   fi
15993 
15994 
15995   # Setup OPENJDK_BUILD_CPU_OSARCH, which is used to set the os.arch Java system property
15996   OPENJDK_BUILD_CPU_OSARCH="$OPENJDK_BUILD_CPU"
15997   if test "x$OPENJDK_BUILD_OS" = xlinux && test "x$OPENJDK_BUILD_CPU" = xx86; then
15998     # On linux only, we replace x86 with i386.
15999     OPENJDK_BUILD_CPU_OSARCH="i386"
16000   elif test "x$OPENJDK_BUILD_OS" != xmacosx && test "x$OPENJDK_BUILD_CPU" = xx86_64; then
16001     # On all platforms except macosx, we replace x86_64 with amd64.
16002     OPENJDK_BUILD_CPU_OSARCH="amd64"
16003   fi
16004 
16005 
16006   OPENJDK_BUILD_CPU_JLI="$OPENJDK_BUILD_CPU"
16007   if test "x$OPENJDK_BUILD_CPU" = xx86; then
16008     OPENJDK_BUILD_CPU_JLI="i386"
16009   elif test "x$OPENJDK_BUILD_OS" != xmacosx && test "x$OPENJDK_BUILD_CPU" = xx86_64; then
16010     # On all platforms except macosx, we replace x86_64 with amd64.
16011     OPENJDK_BUILD_CPU_JLI="amd64"
16012   fi
16013   # Now setup the -D flags for building libjli.
16014   OPENJDK_BUILD_CPU_JLI_CFLAGS="-DLIBARCHNAME='\"$OPENJDK_BUILD_CPU_JLI\"'"
16015   if test "x$OPENJDK_BUILD_OS" = xsolaris; then
16016     if test "x$OPENJDK_BUILD_CPU_ARCH" = xsparc; then
16017       OPENJDK_BUILD_CPU_JLI_CFLAGS="$OPENJDK_BUILD_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"sparc\"' -DLIBARCH64NAME='\"sparcv9\"'"
16018     elif test "x$OPENJDK_BUILD_CPU_ARCH" = xx86; then
16019       OPENJDK_BUILD_CPU_JLI_CFLAGS="$OPENJDK_BUILD_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"i386\"' -DLIBARCH64NAME='\"amd64\"'"
16020     fi
16021   fi
16022 
16023 
16024   if test "x$OPENJDK_BUILD_OS" = xmacosx; then
16025       OPENJDK_BUILD_OS_EXPORT_DIR=macosx
16026   else
16027       OPENJDK_BUILD_OS_EXPORT_DIR=${OPENJDK_BUILD_OS_TYPE}
16028   fi
16029 
16030 
16031   # The new version string in JDK 9 also defined new naming of OS and ARCH for bundles
16032   # Macosx is osx and x86_64 is x64
16033   if test "x$OPENJDK_BUILD_OS" = xmacosx; then
16034     OPENJDK_BUILD_OS_BUNDLE="osx"
16035   else
16036     OPENJDK_BUILD_OS_BUNDLE="$OPENJDK_TARGET_OS"
16037   fi
16038   if test "x$OPENJDK_BUILD_CPU" = xx86_64; then
16039     OPENJDK_BUILD_CPU_BUNDLE="x64"
16040   else
16041     OPENJDK_BUILD_CPU_BUNDLE="$OPENJDK_BUILD_CPU"
16042   fi
16043   OPENJDK_BUILD_BUNDLE_PLATFORM="${OPENJDK_BUILD_OS_BUNDLE}-${OPENJDK_BUILD_CPU_BUNDLE}"
16044 
16045 
16046 
16047 
16048   if test "x$OPENJDK_BUILD_CPU_BITS" = x64; then
16049     A_LP64="LP64:="
16050     # -D_LP64=1 is only set on linux and mac. Setting on windows causes diff in
16051     # unpack200.exe
16052     if test "x$OPENJDK_BUILD_OS" = xlinux || test "x$OPENJDK_BUILD_OS" = xmacosx; then
16053       OPENJDK_BUILD_ADD_LP64="-D_LP64=1"
16054     fi
16055   fi
16056   LP64=$A_LP64
16057 
16058 
16059   if test "x$COMPILE_TYPE" = "xcross"; then
16060     # FIXME: ... or should this include reduced builds..?
16061     DEFINE_CROSS_COMPILE_ARCH="CROSS_COMPILE_ARCH:=$OPENJDK_BUILD_CPU_LEGACY"
16062   else
16063     DEFINE_CROSS_COMPILE_ARCH=""
16064   fi
16065 
16066 
16067   # Convert openjdk platform names to hotspot names
16068 
16069   HOTSPOT_BUILD_OS=${OPENJDK_BUILD_OS}
16070   if test "x$OPENJDK_BUILD_OS" = xmacosx; then
16071     HOTSPOT_BUILD_OS=bsd
16072   fi
16073 
16074 
16075   HOTSPOT_BUILD_OS_TYPE=${OPENJDK_BUILD_OS_TYPE}
16076   if test "x$OPENJDK_BUILD_OS_TYPE" = xunix; then
16077     HOTSPOT_BUILD_OS_TYPE=posix
16078   fi
16079 
16080 
16081   HOTSPOT_BUILD_CPU=${OPENJDK_BUILD_CPU}
16082   if test "x$OPENJDK_BUILD_CPU" = xx86; then
16083     HOTSPOT_BUILD_CPU=x86_32
16084   elif test "x$OPENJDK_BUILD_CPU" = xsparcv9; then
16085     HOTSPOT_BUILD_CPU=sparc
16086   elif test "x$OPENJDK_BUILD_CPU" = xppc64; then
16087     HOTSPOT_BUILD_CPU=ppc_64
16088   elif test "x$OPENJDK_BUILD_CPU" = xppc64le; then
16089     HOTSPOT_BUILD_CPU=ppc_64
16090   fi
16091 
16092 
16093   # This is identical with OPENJDK_*, but define anyway for consistency.
16094   HOTSPOT_BUILD_CPU_ARCH=${OPENJDK_BUILD_CPU_ARCH}
16095 
16096 
16097   # Setup HOTSPOT_BUILD_CPU_DEFINE
16098   if test "x$OPENJDK_BUILD_CPU" = xx86; then
16099     HOTSPOT_BUILD_CPU_DEFINE=IA32
16100   elif test "x$OPENJDK_BUILD_CPU" = xx86_64; then
16101     HOTSPOT_BUILD_CPU_DEFINE=AMD64
16102   elif test "x$OPENJDK_BUILD_CPU" = xsparcv9; then
16103     HOTSPOT_BUILD_CPU_DEFINE=SPARC
16104   elif test "x$OPENJDK_BUILD_CPU" = xaarch64; then
16105     HOTSPOT_BUILD_CPU_DEFINE=AARCH64
16106   elif test "x$OPENJDK_BUILD_CPU" = xppc64; then
16107     HOTSPOT_BUILD_CPU_DEFINE=PPC64
16108   elif test "x$OPENJDK_BUILD_CPU" = xppc64le; then
16109     HOTSPOT_BUILD_CPU_DEFINE=PPC64
16110 
16111   # The cpu defines below are for zero, we don't support them directly.
16112   elif test "x$OPENJDK_BUILD_CPU" = xsparc; then
16113     HOTSPOT_BUILD_CPU_DEFINE=SPARC
16114   elif test "x$OPENJDK_BUILD_CPU" = xppc; then
16115     HOTSPOT_BUILD_CPU_DEFINE=PPC32
16116   elif test "x$OPENJDK_BUILD_CPU" = xs390; then
16117     HOTSPOT_BUILD_CPU_DEFINE=S390
16118   elif test "x$OPENJDK_BUILD_CPU" = xs390x; then
16119     HOTSPOT_BUILD_CPU_DEFINE=S390
16120   fi
16121 
16122 
16123 
16124 
16125   # ZERO_ARCHDEF is used to enable architecture-specific code.
16126   # This is used in legacy hotspot build.
16127   ZERO_ARCHDEF="$HOTSPOT_TARGET_CPU_DEFINE"
16128 
16129 
16130 
16131 
16132 
16133 # Continue setting up basic stuff. Most remaining code require fundamental tools.
16134 
16135   # Save the current directory this script was started from
16136   CURDIR="$PWD"
16137 
16138   # We might need to rewrite ORIGINAL_PATH, if it includes "#", to quote them
16139   # for make. We couldn't do this when we retrieved ORIGINAL_PATH, since SED
16140   # was not available at that time.
16141   REWRITTEN_PATH=`$ECHO "$ORIGINAL_PATH" | $SED -e 's/#/\\\\#/g'`
16142   if test "x$REWRITTEN_PATH" != "x$ORIGINAL_PATH"; then
16143     ORIGINAL_PATH="$REWRITTEN_PATH"
16144     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting ORIGINAL_PATH to $REWRITTEN_PATH" >&5
16145 $as_echo "$as_me: Rewriting ORIGINAL_PATH to $REWRITTEN_PATH" >&6;}
16146   fi
16147 
16148   if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
16149     PATH_SEP=";"
16150 
16151   SRC_ROOT_LENGTH=`$THEPWDCMD -L|$WC -m`
16152   if test $SRC_ROOT_LENGTH -gt 100; then
16153     as_fn_error $? "Your base path is too long. It is $SRC_ROOT_LENGTH characters long, but only 100 is supported" "$LINENO" 5
16154   fi
16155 
16156   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16157     { $as_echo "$as_me:${as_lineno-$LINENO}: checking cygwin release" >&5
16158 $as_echo_n "checking cygwin release... " >&6; }
16159     CYGWIN_VERSION=`$UNAME -r`
16160     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_VERSION" >&5
16161 $as_echo "$CYGWIN_VERSION" >&6; }
16162     WINDOWS_ENV_VENDOR='cygwin'
16163     WINDOWS_ENV_VERSION="$CYGWIN_VERSION"
16164 
16165     CYGWIN_VERSION_OLD=`$ECHO $CYGWIN_VERSION | $GREP -e '^1\.0-6'`
16166     if test "x$CYGWIN_VERSION_OLD" != x; then
16167       { $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
16168 $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;}
16169       as_fn_error $? "Cannot continue" "$LINENO" 5
16170     fi
16171     if test "x$CYGPATH" = x; then
16172       as_fn_error $? "Something is wrong with your cygwin installation since I cannot find cygpath.exe in your path" "$LINENO" 5
16173     fi
16174     { $as_echo "$as_me:${as_lineno-$LINENO}: checking cygwin root directory as unix-style path" >&5
16175 $as_echo_n "checking cygwin root directory as unix-style path... " >&6; }
16176     # The cmd output ends with Windows line endings (CR/LF), the grep command will strip that away
16177     cygwin_winpath_root=`cd / ; cmd /c cd | $GREP ".*"`
16178     # Force cygpath to report the proper root by including a trailing space, and then stripping it off again.
16179     CYGWIN_ROOT_PATH=`$CYGPATH -u "$cygwin_winpath_root " | $CUT -f 1 -d " "`
16180     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_ROOT_PATH" >&5
16181 $as_echo "$CYGWIN_ROOT_PATH" >&6; }
16182     WINDOWS_ENV_ROOT_PATH="$CYGWIN_ROOT_PATH"
16183     test_cygdrive_prefix=`$ECHO $CYGWIN_ROOT_PATH | $GREP ^/cygdrive/`
16184     if test "x$test_cygdrive_prefix" = x; then
16185       as_fn_error $? "Your cygdrive prefix is not /cygdrive. This is currently not supported. Change with mount -c." "$LINENO" 5
16186     fi
16187   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16188     { $as_echo "$as_me:${as_lineno-$LINENO}: checking msys release" >&5
16189 $as_echo_n "checking msys release... " >&6; }
16190     MSYS_VERSION=`$UNAME -r`
16191     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSYS_VERSION" >&5
16192 $as_echo "$MSYS_VERSION" >&6; }
16193 
16194     WINDOWS_ENV_VENDOR='msys'
16195     WINDOWS_ENV_VERSION="$MSYS_VERSION"
16196 
16197     { $as_echo "$as_me:${as_lineno-$LINENO}: checking msys root directory as unix-style path" >&5
16198 $as_echo_n "checking msys root directory as unix-style path... " >&6; }
16199     # The cmd output ends with Windows line endings (CR/LF), the grep command will strip that away
16200     MSYS_ROOT_PATH=`cd / ; cmd /c cd | $GREP ".*"`
16201 
16202   windows_path="$MSYS_ROOT_PATH"
16203   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16204     unix_path=`$CYGPATH -u "$windows_path"`
16205     MSYS_ROOT_PATH="$unix_path"
16206   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16207     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16208     MSYS_ROOT_PATH="$unix_path"
16209   fi
16210 
16211     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSYS_ROOT_PATH" >&5
16212 $as_echo "$MSYS_ROOT_PATH" >&6; }
16213     WINDOWS_ENV_ROOT_PATH="$MSYS_ROOT_PATH"
16214   else
16215     as_fn_error $? "Unknown Windows environment. Neither cygwin nor msys was detected." "$LINENO" 5
16216   fi
16217 
16218   # Test if windows or unix (cygwin/msys) find is first in path.
16219   { $as_echo "$as_me:${as_lineno-$LINENO}: checking what kind of 'find' is first on the PATH" >&5
16220 $as_echo_n "checking what kind of 'find' is first on the PATH... " >&6; }
16221   FIND_BINARY_OUTPUT=`find --version 2>&1`
16222   if test "x`echo $FIND_BINARY_OUTPUT | $GREP GNU`" != x; then
16223     { $as_echo "$as_me:${as_lineno-$LINENO}: result: unix style" >&5
16224 $as_echo "unix style" >&6; }
16225   elif test "x`echo $FIND_BINARY_OUTPUT | $GREP FIND`" != x; then
16226     { $as_echo "$as_me:${as_lineno-$LINENO}: result: Windows" >&5
16227 $as_echo "Windows" >&6; }
16228     { $as_echo "$as_me:${as_lineno-$LINENO}: Your path contains Windows tools (C:\Windows\system32) before your unix (cygwin or msys) tools." >&5
16229 $as_echo "$as_me: Your path contains Windows tools (C:\Windows\system32) before your unix (cygwin or msys) tools." >&6;}
16230     { $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
16231 $as_echo "$as_me: This will not work. Please correct and make sure /usr/bin (or similar) is first in path." >&6;}
16232     as_fn_error $? "Cannot continue" "$LINENO" 5
16233   else
16234     { $as_echo "$as_me:${as_lineno-$LINENO}: result: unknown" >&5
16235 $as_echo "unknown" >&6; }
16236     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: It seems that your find utility is non-standard." >&5
16237 $as_echo "$as_me: WARNING: It seems that your find utility is non-standard." >&2;}
16238   fi
16239 
16240   else
16241     PATH_SEP=":"
16242   fi
16243 
16244 
16245   # We get the top-level directory from the supporting wrappers.
16246   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for top-level directory" >&5
16247 $as_echo_n "checking for top-level directory... " >&6; }
16248   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOPDIR" >&5
16249 $as_echo "$TOPDIR" >&6; }
16250 
16251 
16252   # Save the original version of TOPDIR for string comparisons
16253   ORIGINAL_TOPDIR="$TOPDIR"
16254 
16255 
16256   # We can only call BASIC_FIXUP_PATH after BASIC_CHECK_PATHS_WINDOWS.
16257 
16258   # Only process if variable expands to non-empty
16259 
16260   if test "x$CURDIR" != x; then
16261     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16262 
16263   # Input might be given as Windows format, start by converting to
16264   # unix format.
16265   path="$CURDIR"
16266   new_path=`$CYGPATH -u "$path"`
16267 
16268   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
16269   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
16270   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
16271   # "foo.exe" is OK but "foo" is an error.
16272   #
16273   # This test is therefore slightly more accurate than "test -f" to check for file precense.
16274   # It is also a way to make sure we got the proper file name for the real test later on.
16275   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
16276   if test "x$test_shortpath" = x; then
16277     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CURDIR, which resolves as \"$path\", is invalid." >&5
16278 $as_echo "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid." >&6;}
16279     as_fn_error $? "Cannot locate the the path of CURDIR" "$LINENO" 5
16280   fi
16281 
16282   # Call helper function which possibly converts this using DOS-style short mode.
16283   # If so, the updated path is stored in $new_path.
16284 
16285   input_path="$new_path"
16286   # Check if we need to convert this using DOS-style short mode. If the path
16287   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16288   # take no chances and rewrite it.
16289   # Note: m4 eats our [], so we need to use [ and ] instead.
16290   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
16291   if test "x$has_forbidden_chars" != x; then
16292     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16293     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
16294     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
16295     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
16296       # Going to short mode and back again did indeed matter. Since short mode is
16297       # case insensitive, let's make it lowercase to improve readability.
16298       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16299       # Now convert it back to Unix-style (cygpath)
16300       input_path=`$CYGPATH -u "$shortmode_path"`
16301       new_path="$input_path"
16302     fi
16303   fi
16304 
16305   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
16306   if test "x$test_cygdrive_prefix" = x; then
16307     # As a simple fix, exclude /usr/bin since it's not a real path.
16308     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
16309       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
16310       # a path prefixed by /cygdrive for fixpath to work.
16311       new_path="$CYGWIN_ROOT_PATH$input_path"
16312     fi
16313   fi
16314 
16315 
16316   if test "x$path" != "x$new_path"; then
16317     CURDIR="$new_path"
16318     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
16319 $as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
16320   fi
16321 
16322     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16323 
16324   path="$CURDIR"
16325   has_colon=`$ECHO $path | $GREP ^.:`
16326   new_path="$path"
16327   if test "x$has_colon" = x; then
16328     # Not in mixed or Windows style, start by that.
16329     new_path=`cmd //c echo $path`
16330   fi
16331 
16332 
16333   input_path="$new_path"
16334   # Check if we need to convert this using DOS-style short mode. If the path
16335   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16336   # take no chances and rewrite it.
16337   # Note: m4 eats our [], so we need to use [ and ] instead.
16338   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
16339   if test "x$has_forbidden_chars" != x; then
16340     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16341     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16342   fi
16343 
16344 
16345   windows_path="$new_path"
16346   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16347     unix_path=`$CYGPATH -u "$windows_path"`
16348     new_path="$unix_path"
16349   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16350     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16351     new_path="$unix_path"
16352   fi
16353 
16354   if test "x$path" != "x$new_path"; then
16355     CURDIR="$new_path"
16356     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
16357 $as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
16358   fi
16359 
16360   # Save the first 10 bytes of this path to the storage, so fixpath can work.
16361   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
16362 
16363     else
16364       # We're on a unix platform. Hooray! :)
16365       path="$CURDIR"
16366       has_space=`$ECHO "$path" | $GREP " "`
16367       if test "x$has_space" != x; then
16368         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CURDIR, which resolves as \"$path\", is invalid." >&5
16369 $as_echo "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid." >&6;}
16370         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
16371       fi
16372 
16373       # Use eval to expand a potential ~
16374       eval path="$path"
16375       if test ! -f "$path" && test ! -d "$path"; then
16376         as_fn_error $? "The path of CURDIR, which resolves as \"$path\", is not found." "$LINENO" 5
16377       fi
16378 
16379       if test -d "$path"; then
16380         CURDIR="`cd "$path"; $THEPWDCMD -L`"
16381       else
16382         dir="`$DIRNAME "$path"`"
16383         base="`$BASENAME "$path"`"
16384         CURDIR="`cd "$dir"; $THEPWDCMD -L`/$base"
16385       fi
16386     fi
16387   fi
16388 
16389 
16390   # Only process if variable expands to non-empty
16391 
16392   if test "x$TOPDIR" != x; then
16393     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16394 
16395   # Input might be given as Windows format, start by converting to
16396   # unix format.
16397   path="$TOPDIR"
16398   new_path=`$CYGPATH -u "$path"`
16399 
16400   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
16401   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
16402   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
16403   # "foo.exe" is OK but "foo" is an error.
16404   #
16405   # This test is therefore slightly more accurate than "test -f" to check for file precense.
16406   # It is also a way to make sure we got the proper file name for the real test later on.
16407   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
16408   if test "x$test_shortpath" = x; then
16409     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of TOPDIR, which resolves as \"$path\", is invalid." >&5
16410 $as_echo "$as_me: The path of TOPDIR, which resolves as \"$path\", is invalid." >&6;}
16411     as_fn_error $? "Cannot locate the the path of TOPDIR" "$LINENO" 5
16412   fi
16413 
16414   # Call helper function which possibly converts this using DOS-style short mode.
16415   # If so, the updated path is stored in $new_path.
16416 
16417   input_path="$new_path"
16418   # Check if we need to convert this using DOS-style short mode. If the path
16419   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16420   # take no chances and rewrite it.
16421   # Note: m4 eats our [], so we need to use [ and ] instead.
16422   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
16423   if test "x$has_forbidden_chars" != x; then
16424     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16425     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
16426     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
16427     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
16428       # Going to short mode and back again did indeed matter. Since short mode is
16429       # case insensitive, let's make it lowercase to improve readability.
16430       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16431       # Now convert it back to Unix-style (cygpath)
16432       input_path=`$CYGPATH -u "$shortmode_path"`
16433       new_path="$input_path"
16434     fi
16435   fi
16436 
16437   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
16438   if test "x$test_cygdrive_prefix" = x; then
16439     # As a simple fix, exclude /usr/bin since it's not a real path.
16440     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
16441       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
16442       # a path prefixed by /cygdrive for fixpath to work.
16443       new_path="$CYGWIN_ROOT_PATH$input_path"
16444     fi
16445   fi
16446 
16447 
16448   if test "x$path" != "x$new_path"; then
16449     TOPDIR="$new_path"
16450     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting TOPDIR to \"$new_path\"" >&5
16451 $as_echo "$as_me: Rewriting TOPDIR to \"$new_path\"" >&6;}
16452   fi
16453 
16454     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16455 
16456   path="$TOPDIR"
16457   has_colon=`$ECHO $path | $GREP ^.:`
16458   new_path="$path"
16459   if test "x$has_colon" = x; then
16460     # Not in mixed or Windows style, start by that.
16461     new_path=`cmd //c echo $path`
16462   fi
16463 
16464 
16465   input_path="$new_path"
16466   # Check if we need to convert this using DOS-style short mode. If the path
16467   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16468   # take no chances and rewrite it.
16469   # Note: m4 eats our [], so we need to use [ and ] instead.
16470   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
16471   if test "x$has_forbidden_chars" != x; then
16472     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16473     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16474   fi
16475 
16476 
16477   windows_path="$new_path"
16478   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16479     unix_path=`$CYGPATH -u "$windows_path"`
16480     new_path="$unix_path"
16481   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16482     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16483     new_path="$unix_path"
16484   fi
16485 
16486   if test "x$path" != "x$new_path"; then
16487     TOPDIR="$new_path"
16488     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting TOPDIR to \"$new_path\"" >&5
16489 $as_echo "$as_me: Rewriting TOPDIR to \"$new_path\"" >&6;}
16490   fi
16491 
16492   # Save the first 10 bytes of this path to the storage, so fixpath can work.
16493   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
16494 
16495     else
16496       # We're on a unix platform. Hooray! :)
16497       path="$TOPDIR"
16498       has_space=`$ECHO "$path" | $GREP " "`
16499       if test "x$has_space" != x; then
16500         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of TOPDIR, which resolves as \"$path\", is invalid." >&5
16501 $as_echo "$as_me: The path of TOPDIR, which resolves as \"$path\", is invalid." >&6;}
16502         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
16503       fi
16504 
16505       # Use eval to expand a potential ~
16506       eval path="$path"
16507       if test ! -f "$path" && test ! -d "$path"; then
16508         as_fn_error $? "The path of TOPDIR, which resolves as \"$path\", is not found." "$LINENO" 5
16509       fi
16510 
16511       if test -d "$path"; then
16512         TOPDIR="`cd "$path"; $THEPWDCMD -L`"
16513       else
16514         dir="`$DIRNAME "$path"`"
16515         base="`$BASENAME "$path"`"
16516         TOPDIR="`cd "$dir"; $THEPWDCMD -L`/$base"
16517       fi
16518     fi
16519   fi
16520 
16521   # SRC_ROOT is a traditional alias for TOPDIR.
16522   SRC_ROOT=$TOPDIR
16523 
16524   # Calculate a canonical version of TOPDIR for string comparisons
16525   CANONICAL_TOPDIR=$TOPDIR
16526 
16527   if test "x$OPENJDK_BUILD_OS" != xwindows; then
16528     # Follow a chain of symbolic links. Use readlink
16529     # where it exists, else fall back to horribly
16530     # complicated shell code.
16531     if test "x$READLINK_TESTED" != yes; then
16532       # On MacOSX there is a readlink tool with a different
16533       # purpose than the GNU readlink tool. Check the found readlink.
16534       ISGNU=`$READLINK --version 2>&1 | $GREP GNU`
16535       if test "x$ISGNU" = x; then
16536         # A readlink that we do not know how to use.
16537         # Are there other non-GNU readlinks out there?
16538         READLINK_TESTED=yes
16539         READLINK=
16540       fi
16541     fi
16542 
16543     if test "x$READLINK" != x; then
16544       CANONICAL_TOPDIR=`$READLINK -f $CANONICAL_TOPDIR`
16545     else
16546       # Save the current directory for restoring afterwards
16547       STARTDIR=$PWD
16548       COUNTER=0
16549       sym_link_dir=`$DIRNAME $CANONICAL_TOPDIR`
16550       sym_link_file=`$BASENAME $CANONICAL_TOPDIR`
16551       cd $sym_link_dir
16552       # Use -P flag to resolve symlinks in directories.
16553       cd `$THEPWDCMD -P`
16554       sym_link_dir=`$THEPWDCMD -P`
16555       # Resolve file symlinks
16556       while test $COUNTER -lt 20; do
16557         ISLINK=`$LS -l $sym_link_dir/$sym_link_file | $GREP '\->' | $SED -e 's/.*-> \(.*\)/\1/'`
16558         if test "x$ISLINK" == x; then
16559           # This is not a symbolic link! We are done!
16560           break
16561         fi
16562         # Again resolve directory symlinks since the target of the just found
16563         # link could be in a different directory
16564         cd `$DIRNAME $ISLINK`
16565         sym_link_dir=`$THEPWDCMD -P`
16566         sym_link_file=`$BASENAME $ISLINK`
16567         let COUNTER=COUNTER+1
16568       done
16569       cd $STARTDIR
16570       CANONICAL_TOPDIR=$sym_link_dir/$sym_link_file
16571     fi
16572   fi
16573 
16574 
16575 
16576   # Locate the directory of this script.
16577   AUTOCONF_DIR=$TOPDIR/common/autoconf
16578 
16579   # Setup username (for use in adhoc version strings etc)
16580   # Outer [ ] to quote m4.
16581    USERNAME=`$ECHO "$USER" | $TR -d -c '[a-z][A-Z][0-9]'`
16582 
16583 
16584 
16585 # Check if it's a pure open build or if custom sources are to be used.
16586 
16587   # Check whether --enable-openjdk-only was given.
16588 if test "${enable_openjdk_only+set}" = set; then :
16589   enableval=$enable_openjdk_only;
16590 else
16591   enable_openjdk_only="no"
16592 fi
16593 
16594 
16595   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if custom source is suppressed (openjdk-only)" >&5
16596 $as_echo_n "checking if custom source is suppressed (openjdk-only)... " >&6; }
16597   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $enable_openjdk_only" >&5
16598 $as_echo "$enable_openjdk_only" >&6; }
16599   if test "x$enable_openjdk_only" = "xyes"; then
16600     SUPPRESS_CUSTOM_EXTENSIONS="true"
16601   elif test "x$enable_openjdk_only" = "xno"; then
16602     SUPPRESS_CUSTOM_EXTENSIONS="false"
16603   else
16604     as_fn_error $? "Invalid value for --enable-openjdk-only: $enable_openjdk_only" "$LINENO" 5
16605   fi
16606 
16607   # custom-make-dir is deprecated. Please use your custom-hook.m4 to override
16608   # the IncludeCustomExtension macro.
16609 
16610 
16611 # Check whether --with-custom-make-dir was given.
16612 if test "${with_custom_make_dir+set}" = set; then :
16613   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
16614 $as_echo "$as_me: WARNING: Option --with-custom-make-dir is deprecated and will be ignored." >&2;}
16615 fi
16616 
16617 
16618 
16619 
16620 # These are needed to be able to create a configuration name (and thus the output directory)
16621 
16622   { $as_echo "$as_me:${as_lineno-$LINENO}: checking which variant of the JDK to build" >&5
16623 $as_echo_n "checking which variant of the JDK to build... " >&6; }
16624 
16625 # Check whether --with-jdk-variant was given.
16626 if test "${with_jdk_variant+set}" = set; then :
16627   withval=$with_jdk_variant;
16628 fi
16629 
16630 
16631   if test "x$with_jdk_variant" = xnormal || test "x$with_jdk_variant" = x; then
16632     JDK_VARIANT="normal"
16633   else
16634     as_fn_error $? "The available JDK variants are: normal" "$LINENO" 5
16635   fi
16636 
16637 
16638 
16639   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JDK_VARIANT" >&5
16640 $as_echo "$JDK_VARIANT" >&6; }
16641 
16642 
16643   DEBUG_LEVEL="release"
16644   { $as_echo "$as_me:${as_lineno-$LINENO}: checking which debug level to use" >&5
16645 $as_echo_n "checking which debug level to use... " >&6; }
16646   # Check whether --enable-debug was given.
16647 if test "${enable_debug+set}" = set; then :
16648   enableval=$enable_debug;
16649         ENABLE_DEBUG="${enableval}"
16650         DEBUG_LEVEL="fastdebug"
16651 
16652 else
16653   ENABLE_DEBUG="no"
16654 fi
16655 
16656 
16657 
16658 # Check whether --with-debug-level was given.
16659 if test "${with_debug_level+set}" = set; then :
16660   withval=$with_debug_level;
16661         DEBUG_LEVEL="${withval}"
16662         if test "x$ENABLE_DEBUG" = xyes; then
16663           as_fn_error $? "You cannot use both --enable-debug and --with-debug-level at the same time." "$LINENO" 5
16664         fi
16665 
16666 fi
16667 
16668   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEBUG_LEVEL" >&5
16669 $as_echo "$DEBUG_LEVEL" >&6; }
16670 
16671   if test "x$DEBUG_LEVEL" != xrelease && \
16672       test "x$DEBUG_LEVEL" != xoptimized && \
16673       test "x$DEBUG_LEVEL" != xfastdebug && \
16674       test "x$DEBUG_LEVEL" != xslowdebug; then
16675     as_fn_error $? "Allowed debug levels are: release, fastdebug, slowdebug and optimized" "$LINENO" 5
16676   fi
16677 
16678   # Translate DEBUG_LEVEL to debug level used by Hotspot
16679   HOTSPOT_DEBUG_LEVEL="$DEBUG_LEVEL"
16680   if test "x$DEBUG_LEVEL" = xrelease; then
16681     HOTSPOT_DEBUG_LEVEL="product"
16682   elif test "x$DEBUG_LEVEL" = xslowdebug; then
16683     HOTSPOT_DEBUG_LEVEL="debug"
16684   fi
16685 
16686   if test "x$DEBUG_LEVEL" = xoptimized; then
16687     # The debug level 'optimized' is a little special because it is currently only
16688     # applicable to the HotSpot build where it means to build a completely
16689     # optimized version of the VM without any debugging code (like for the
16690     # 'release' debug level which is called 'product' in the HotSpot build) but
16691     # with the exception that it can contain additional code which is otherwise
16692     # protected by '#ifndef PRODUCT' macros. These 'optimized' builds are used to
16693     # test new and/or experimental features which are not intended for customer
16694     # shipment. Because these new features need to be tested and benchmarked in
16695     # real world scenarios, we want to build the containing JDK at the 'release'
16696     # debug level.
16697     DEBUG_LEVEL="release"
16698   fi
16699 
16700 
16701 
16702 
16703 
16704 
16705 # Check whether --with-jvm-variants was given.
16706 if test "${with_jvm_variants+set}" = set; then :
16707   withval=$with_jvm_variants;
16708 fi
16709 
16710 
16711   if test "x$with_jvm_variants" = x; then
16712     with_jvm_variants="server"
16713   fi
16714   JVM_VARIANTS_OPT="$with_jvm_variants"
16715 
16716   # Has the user listed more than one variant?
16717   # Additional [] needed to keep m4 from mangling shell constructs.
16718   if  [[ "$JVM_VARIANTS_OPT" =~ "," ]] ; then
16719     BUILDING_MULTIPLE_JVM_VARIANTS=true
16720   else
16721     BUILDING_MULTIPLE_JVM_VARIANTS=false
16722   fi
16723   # Replace the commas with AND for use in the build directory name.
16724   JVM_VARIANTS_WITH_AND=`$ECHO "$JVM_VARIANTS_OPT" | $SED -e 's/,/AND/g'`
16725 
16726   { $as_echo "$as_me:${as_lineno-$LINENO}: checking which variants of the JVM to build" >&5
16727 $as_echo_n "checking which variants of the JVM to build... " >&6; }
16728   # JVM_VARIANTS is a space-separated list.
16729   # Also use minimal, not minimal1 (which is kept for backwards compatibility).
16730   JVM_VARIANTS=`$ECHO $JVM_VARIANTS_OPT | $SED -e 's/,/ /g' -e 's/minimal1/minimal/'`
16731   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JVM_VARIANTS" >&5
16732 $as_echo "$JVM_VARIANTS" >&6; }
16733 
16734   # Check that the selected variants are valid
16735 
16736   # grep filter function inspired by a comment to http://stackoverflow.com/a/1617326
16737   # Notice that the original variant failes on SLES 10 and 11
16738   NEEDLE=${VALID_JVM_VARIANTS// /$'\n'}
16739   STACK=${JVM_VARIANTS// /$'\n'}
16740   INVALID_VARIANTS=`$GREP -Fvx "${NEEDLE}" <<< "${STACK}"`
16741   if test "x$INVALID_VARIANTS" != x; then
16742     { $as_echo "$as_me:${as_lineno-$LINENO}: Unknown variant(s) specified: $INVALID_VARIANTS" >&5
16743 $as_echo "$as_me: Unknown variant(s) specified: $INVALID_VARIANTS" >&6;}
16744     as_fn_error $? "The available JVM variants are: $VALID_JVM_VARIANTS" "$LINENO" 5
16745   fi
16746 
16747   # All "special" variants share the same output directory ("server")
16748   VALID_MULTIPLE_JVM_VARIANTS="server client minimal"
16749   NEEDLE=${VALID_MULTIPLE_JVM_VARIANTS// /$'\n'}
16750   STACK=${JVM_VARIANTS// /$'\n'}
16751   INVALID_MULTIPLE_VARIANTS=`$GREP -Fvx "${NEEDLE}" <<< "${STACK}"`
16752   if  test "x$INVALID_MULTIPLE_VARIANTS" != x && test "x$BUILDING_MULTIPLE_JVM_VARIANTS" = xtrue; then
16753     as_fn_error $? "You cannot build multiple variants with anything else than $VALID_MULTIPLE_JVM_VARIANTS." "$LINENO" 5
16754   fi
16755 
16756 
16757 
16758 
16759   if   [[ " $JVM_VARIANTS " =~ " zero " ]]   ||   [[ " $JVM_VARIANTS " =~ " zeroshark " ]]  ; then
16760     # zero behaves as a platform and rewrites these values. This is really weird. :(
16761     # We are guaranteed that we do not build any other variants when building zero.
16762     HOTSPOT_TARGET_CPU=zero
16763     HOTSPOT_TARGET_CPU_ARCH=zero
16764   fi
16765 
16766 
16767 # With basic setup done, call the custom early hook.
16768 
16769 
16770 # Check if we have devkits, extra paths or sysroot set.
16771 
16772 
16773 # Check whether --with-devkit was given.
16774 if test "${with_devkit+set}" = set; then :
16775   withval=$with_devkit;
16776 
16777   # Only process if variable expands to non-empty
16778 
16779   if test "x$with_devkit" != x; then
16780     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16781 
16782   # Input might be given as Windows format, start by converting to
16783   # unix format.
16784   path="$with_devkit"
16785   new_path=`$CYGPATH -u "$path"`
16786 
16787   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
16788   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
16789   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
16790   # "foo.exe" is OK but "foo" is an error.
16791   #
16792   # This test is therefore slightly more accurate than "test -f" to check for file precense.
16793   # It is also a way to make sure we got the proper file name for the real test later on.
16794   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
16795   if test "x$test_shortpath" = x; then
16796     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
16797 $as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
16798     as_fn_error $? "Cannot locate the the path of with_devkit" "$LINENO" 5
16799   fi
16800 
16801   # Call helper function which possibly converts this using DOS-style short mode.
16802   # If so, the updated path is stored in $new_path.
16803 
16804   input_path="$new_path"
16805   # Check if we need to convert this using DOS-style short mode. If the path
16806   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16807   # take no chances and rewrite it.
16808   # Note: m4 eats our [], so we need to use [ and ] instead.
16809   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
16810   if test "x$has_forbidden_chars" != x; then
16811     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16812     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
16813     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
16814     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
16815       # Going to short mode and back again did indeed matter. Since short mode is
16816       # case insensitive, let's make it lowercase to improve readability.
16817       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16818       # Now convert it back to Unix-style (cygpath)
16819       input_path=`$CYGPATH -u "$shortmode_path"`
16820       new_path="$input_path"
16821     fi
16822   fi
16823 
16824   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
16825   if test "x$test_cygdrive_prefix" = x; then
16826     # As a simple fix, exclude /usr/bin since it's not a real path.
16827     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
16828       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
16829       # a path prefixed by /cygdrive for fixpath to work.
16830       new_path="$CYGWIN_ROOT_PATH$input_path"
16831     fi
16832   fi
16833 
16834 
16835   if test "x$path" != "x$new_path"; then
16836     with_devkit="$new_path"
16837     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
16838 $as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
16839   fi
16840 
16841     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16842 
16843   path="$with_devkit"
16844   has_colon=`$ECHO $path | $GREP ^.:`
16845   new_path="$path"
16846   if test "x$has_colon" = x; then
16847     # Not in mixed or Windows style, start by that.
16848     new_path=`cmd //c echo $path`
16849   fi
16850 
16851 
16852   input_path="$new_path"
16853   # Check if we need to convert this using DOS-style short mode. If the path
16854   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16855   # take no chances and rewrite it.
16856   # Note: m4 eats our [], so we need to use [ and ] instead.
16857   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
16858   if test "x$has_forbidden_chars" != x; then
16859     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16860     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16861   fi
16862 
16863 
16864   windows_path="$new_path"
16865   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16866     unix_path=`$CYGPATH -u "$windows_path"`
16867     new_path="$unix_path"
16868   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16869     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16870     new_path="$unix_path"
16871   fi
16872 
16873   if test "x$path" != "x$new_path"; then
16874     with_devkit="$new_path"
16875     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
16876 $as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
16877   fi
16878 
16879   # Save the first 10 bytes of this path to the storage, so fixpath can work.
16880   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
16881 
16882     else
16883       # We're on a unix platform. Hooray! :)
16884       path="$with_devkit"
16885       has_space=`$ECHO "$path" | $GREP " "`
16886       if test "x$has_space" != x; then
16887         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
16888 $as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
16889         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
16890       fi
16891 
16892       # Use eval to expand a potential ~
16893       eval path="$path"
16894       if test ! -f "$path" && test ! -d "$path"; then
16895         as_fn_error $? "The path of with_devkit, which resolves as \"$path\", is not found." "$LINENO" 5
16896       fi
16897 
16898       if test -d "$path"; then
16899         with_devkit="`cd "$path"; $THEPWDCMD -L`"
16900       else
16901         dir="`$DIRNAME "$path"`"
16902         base="`$BASENAME "$path"`"
16903         with_devkit="`cd "$dir"; $THEPWDCMD -L`/$base"
16904       fi
16905     fi
16906   fi
16907 
16908         DEVKIT_ROOT="$with_devkit"
16909         # Check for a meta data info file in the root of the devkit
16910         if test -f "$DEVKIT_ROOT/devkit.info"; then
16911           . $DEVKIT_ROOT/devkit.info
16912           # This potentially sets the following:
16913           # A descriptive name of the devkit
16914 
16915   if test "x$DEVKIT_NAME" = x; then
16916     eval DEVKIT_NAME="\${DEVKIT_NAME_${OPENJDK_TARGET_CPU}}"
16917   fi
16918 
16919           # Corresponds to --with-extra-path
16920 
16921   if test "x$DEVKIT_EXTRA_PATH" = x; then
16922     eval DEVKIT_EXTRA_PATH="\${DEVKIT_EXTRA_PATH_${OPENJDK_TARGET_CPU}}"
16923   fi
16924 
16925           # Corresponds to --with-toolchain-path
16926 
16927   if test "x$DEVKIT_TOOLCHAIN_PATH" = x; then
16928     eval DEVKIT_TOOLCHAIN_PATH="\${DEVKIT_TOOLCHAIN_PATH_${OPENJDK_TARGET_CPU}}"
16929   fi
16930 
16931           # Corresponds to --with-sysroot
16932 
16933   if test "x$DEVKIT_SYSROOT" = x; then
16934     eval DEVKIT_SYSROOT="\${DEVKIT_SYSROOT_${OPENJDK_TARGET_CPU}}"
16935   fi
16936 
16937 
16938           # Identifies the Visual Studio version in the devkit
16939 
16940   if test "x$DEVKIT_VS_VERSION" = x; then
16941     eval DEVKIT_VS_VERSION="\${DEVKIT_VS_VERSION_${OPENJDK_TARGET_CPU}}"
16942   fi
16943 
16944           # The Visual Studio include environment variable
16945 
16946   if test "x$DEVKIT_VS_INCLUDE" = x; then
16947     eval DEVKIT_VS_INCLUDE="\${DEVKIT_VS_INCLUDE_${OPENJDK_TARGET_CPU}}"
16948   fi
16949 
16950           # The Visual Studio lib environment variable
16951 
16952   if test "x$DEVKIT_VS_LIB" = x; then
16953     eval DEVKIT_VS_LIB="\${DEVKIT_VS_LIB_${OPENJDK_TARGET_CPU}}"
16954   fi
16955 
16956           # Corresponds to --with-msvcr-dll
16957 
16958   if test "x$DEVKIT_MSVCR_DLL" = x; then
16959     eval DEVKIT_MSVCR_DLL="\${DEVKIT_MSVCR_DLL_${OPENJDK_TARGET_CPU}}"
16960   fi
16961 
16962           # Corresponds to --with-msvcp-dll
16963 
16964   if test "x$DEVKIT_MSVCP_DLL" = x; then
16965     eval DEVKIT_MSVCP_DLL="\${DEVKIT_MSVCP_DLL_${OPENJDK_TARGET_CPU}}"
16966   fi
16967 
16968         fi
16969 
16970         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for devkit" >&5
16971 $as_echo_n "checking for devkit... " >&6; }
16972         if test "x$DEVKIT_NAME" != x; then
16973           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEVKIT_NAME in $DEVKIT_ROOT" >&5
16974 $as_echo "$DEVKIT_NAME in $DEVKIT_ROOT" >&6; }
16975         else
16976           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEVKIT_ROOT" >&5
16977 $as_echo "$DEVKIT_ROOT" >&6; }
16978         fi
16979 
16980 
16981   if test "x$DEVKIT_EXTRA_PATH" != x; then
16982     if test "x$EXTRA_PATH" = x; then
16983       EXTRA_PATH="$DEVKIT_EXTRA_PATH"
16984     else
16985       EXTRA_PATH="$DEVKIT_EXTRA_PATH:$EXTRA_PATH"
16986     fi
16987   fi
16988 
16989 
16990         # Fallback default of just /bin if DEVKIT_PATH is not defined
16991         if test "x$DEVKIT_TOOLCHAIN_PATH" = x; then
16992           DEVKIT_TOOLCHAIN_PATH="$DEVKIT_ROOT/bin"
16993         fi
16994 
16995   if test "x$DEVKIT_TOOLCHAIN_PATH" != x; then
16996     if test "x$TOOLCHAIN_PATH" = x; then
16997       TOOLCHAIN_PATH="$DEVKIT_TOOLCHAIN_PATH"
16998     else
16999       TOOLCHAIN_PATH="$DEVKIT_TOOLCHAIN_PATH:$TOOLCHAIN_PATH"
17000     fi
17001   fi
17002 
17003 
17004         # If DEVKIT_SYSROOT is set, use that, otherwise try a couple of known
17005         # places for backwards compatiblity.
17006         if test "x$DEVKIT_SYSROOT" != x; then
17007           SYSROOT="$DEVKIT_SYSROOT"
17008         elif test -d "$DEVKIT_ROOT/$host_alias/libc"; then
17009           SYSROOT="$DEVKIT_ROOT/$host_alias/libc"
17010         elif test -d "$DEVKIT_ROOT/$host/sys-root"; then
17011           SYSROOT="$DEVKIT_ROOT/$host/sys-root"
17012         fi
17013 
17014 
17015 fi
17016 
17017 
17018   # You can force the sysroot if the sysroot encoded into the compiler tools
17019   # is not correct.
17020 
17021 # Check whether --with-sys-root was given.
17022 if test "${with_sys_root+set}" = set; then :
17023   withval=$with_sys_root; SYSROOT=$with_sys_root
17024 
17025 fi
17026 
17027 
17028 
17029 # Check whether --with-sysroot was given.
17030 if test "${with_sysroot+set}" = set; then :
17031   withval=$with_sysroot; SYSROOT=$with_sysroot
17032 
17033 fi
17034 
17035 
17036 
17037 # Check whether --with-tools-dir was given.
17038 if test "${with_tools_dir+set}" = set; then :
17039   withval=$with_tools_dir;
17040   if test "x$with_tools_dir" != x; then
17041     if test "x$TOOLCHAIN_PATH" = x; then
17042       TOOLCHAIN_PATH="$with_tools_dir"
17043     else
17044       TOOLCHAIN_PATH="$with_tools_dir:$TOOLCHAIN_PATH"
17045     fi
17046   fi
17047 
17048 
17049 fi
17050 
17051 
17052 
17053 # Check whether --with-toolchain-path was given.
17054 if test "${with_toolchain_path+set}" = set; then :
17055   withval=$with_toolchain_path;
17056   if test "x$with_toolchain_path" != x; then
17057     if test "x$TOOLCHAIN_PATH" = x; then
17058       TOOLCHAIN_PATH="$with_toolchain_path"
17059     else
17060       TOOLCHAIN_PATH="$with_toolchain_path:$TOOLCHAIN_PATH"
17061     fi
17062   fi
17063 
17064 
17065 fi
17066 
17067 
17068 
17069 # Check whether --with-extra-path was given.
17070 if test "${with_extra_path+set}" = set; then :
17071   withval=$with_extra_path;
17072   if test "x$with_extra_path" != x; then
17073     if test "x$EXTRA_PATH" = x; then
17074       EXTRA_PATH="$with_extra_path"
17075     else
17076       EXTRA_PATH="$with_extra_path:$EXTRA_PATH"
17077     fi
17078   fi
17079 
17080 
17081 fi
17082 
17083 
17084   if test "x$OPENJDK_BUILD_OS" = "xmacosx"; then
17085     # If a devkit has been supplied, find xcodebuild in the toolchain_path.
17086     # If not, detect if Xcode is installed by running xcodebuild -version
17087     # if no Xcode installed, xcodebuild exits with 1
17088     # if Xcode is installed, even if xcode-select is misconfigured, then it exits with 0
17089     if test "x$DEVKIT_ROOT" != x || /usr/bin/xcodebuild -version >/dev/null 2>&1; then
17090       # We need to use xcodebuild in the toolchain dir provided by the user, this will
17091       # fall back on the stub binary in /usr/bin/xcodebuild
17092       # Extract the first word of "xcodebuild", so it can be a program name with args.
17093 set dummy xcodebuild; ac_word=$2
17094 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17095 $as_echo_n "checking for $ac_word... " >&6; }
17096 if ${ac_cv_path_XCODEBUILD+:} false; then :
17097   $as_echo_n "(cached) " >&6
17098 else
17099   case $XCODEBUILD in
17100   [\\/]* | ?:[\\/]*)
17101   ac_cv_path_XCODEBUILD="$XCODEBUILD" # Let the user override the test with a path.
17102   ;;
17103   *)
17104   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17105 for as_dir in $TOOLCHAIN_PATH
17106 do
17107   IFS=$as_save_IFS
17108   test -z "$as_dir" && as_dir=.
17109     for ac_exec_ext in '' $ac_executable_extensions; do
17110   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17111     ac_cv_path_XCODEBUILD="$as_dir/$ac_word$ac_exec_ext"
17112     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17113     break 2
17114   fi
17115 done
17116   done
17117 IFS=$as_save_IFS
17118 
17119   test -z "$ac_cv_path_XCODEBUILD" && ac_cv_path_XCODEBUILD="/usr/bin/xcodebuild"
17120   ;;
17121 esac
17122 fi
17123 XCODEBUILD=$ac_cv_path_XCODEBUILD
17124 if test -n "$XCODEBUILD"; then
17125   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XCODEBUILD" >&5
17126 $as_echo "$XCODEBUILD" >&6; }
17127 else
17128   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17129 $as_echo "no" >&6; }
17130 fi
17131 
17132 
17133     else
17134       # this should result in SYSROOT being empty, unless --with-sysroot is provided
17135       # when only the command line tools are installed there are no SDKs, so headers
17136       # are copied into the system frameworks
17137       XCODEBUILD=
17138 
17139     fi
17140 
17141     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for sdk name" >&5
17142 $as_echo_n "checking for sdk name... " >&6; }
17143 
17144 # Check whether --with-sdk-name was given.
17145 if test "${with_sdk_name+set}" = set; then :
17146   withval=$with_sdk_name; SDKNAME=$with_sdk_name
17147 
17148 fi
17149 
17150     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SDKNAME" >&5
17151 $as_echo "$SDKNAME" >&6; }
17152 
17153     # if toolchain path is specified then don't rely on system headers, they may not compile
17154     HAVE_SYSTEM_FRAMEWORK_HEADERS=0
17155     test -z "$TOOLCHAIN_PATH" && \
17156       HAVE_SYSTEM_FRAMEWORK_HEADERS=`test ! -f /System/Library/Frameworks/Foundation.framework/Headers/Foundation.h; echo $?`
17157 
17158     if test -z "$SYSROOT"; then
17159       if test -n "$XCODEBUILD"; then
17160         # if we don't have system headers, use default SDK name (last resort)
17161         if test -z "$SDKNAME" -a $HAVE_SYSTEM_FRAMEWORK_HEADERS -eq 0; then
17162           SDKNAME=${SDKNAME:-macosx}
17163         fi
17164 
17165         if test -n "$SDKNAME"; then
17166           # Call xcodebuild to determine SYSROOT
17167           SYSROOT=`"$XCODEBUILD" -sdk $SDKNAME -version | $GREP '^Path: ' | $SED 's/Path: //'`
17168         fi
17169       else
17170         if test $HAVE_SYSTEM_FRAMEWORK_HEADERS -eq 0; then
17171           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
17172         fi
17173       fi
17174     else
17175       # warn user if --with-sdk-name was also set
17176       if test -n "$with_sdk_name"; then
17177         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Both SYSROOT and --with-sdk-name are set, only SYSROOT will be used" >&5
17178 $as_echo "$as_me: WARNING: Both SYSROOT and --with-sdk-name are set, only SYSROOT will be used" >&2;}
17179       fi
17180     fi
17181 
17182     if test $HAVE_SYSTEM_FRAMEWORK_HEADERS -eq 0 -a -z "$SYSROOT"; then
17183       # If no system framework headers, then SYSROOT must be set, or we won't build
17184       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
17185     fi
17186 
17187     # Perform a basic sanity test
17188     if test ! -f "$SYSROOT/System/Library/Frameworks/Foundation.framework/Headers/Foundation.h"; then
17189       if test -z "$SYSROOT"; then
17190         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
17191       else
17192         as_fn_error $? "Invalid SDK or SYSROOT path, dependent framework headers not found" "$LINENO" 5
17193       fi
17194     fi
17195 
17196     # set SDKROOT too, Xcode tools will pick it up
17197     SDKROOT=$SYSROOT
17198 
17199   fi
17200 
17201   # Prepend the extra path to the global path
17202 
17203   if test "x$EXTRA_PATH" != x; then
17204     if test "x$PATH" = x; then
17205       PATH="$EXTRA_PATH"
17206     else
17207       PATH="$EXTRA_PATH:$PATH"
17208     fi
17209   fi
17210 
17211 
17212   if test "x$OPENJDK_BUILD_OS" = "xsolaris"; then
17213     # Add extra search paths on solaris for utilities like ar, as, dtrace etc...
17214     PATH="$PATH:/usr/ccs/bin:/usr/sfw/bin:/opt/csw/bin:/usr/sbin"
17215   fi
17216 
17217   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for sysroot" >&5
17218 $as_echo_n "checking for sysroot... " >&6; }
17219   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SYSROOT" >&5
17220 $as_echo "$SYSROOT" >&6; }
17221   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for toolchain path" >&5
17222 $as_echo_n "checking for toolchain path... " >&6; }
17223   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOOLCHAIN_PATH" >&5
17224 $as_echo "$TOOLCHAIN_PATH" >&6; }
17225   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for extra path" >&5
17226 $as_echo_n "checking for extra path... " >&6; }
17227   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXTRA_PATH" >&5
17228 $as_echo "$EXTRA_PATH" >&6; }
17229 
17230 
17231 # To properly create a configuration name, we need to have the OpenJDK target
17232 # and options (variants and debug level) parsed.
17233 
17234 
17235 
17236 # Check whether --with-conf-name was given.
17237 if test "${with_conf_name+set}" = set; then :
17238   withval=$with_conf_name;  CONF_NAME=${with_conf_name}
17239 fi
17240 
17241 
17242   # Test from where we are running configure, in or outside of src root.
17243   { $as_echo "$as_me:${as_lineno-$LINENO}: checking where to store configuration" >&5
17244 $as_echo_n "checking where to store configuration... " >&6; }
17245   if test "x$CURDIR" = "x$SRC_ROOT" || test "x$CURDIR" = "x$SRC_ROOT/common" \
17246       || test "x$CURDIR" = "x$SRC_ROOT/common/autoconf" \
17247       || test "x$CURDIR" = "x$SRC_ROOT/make" ; then
17248     # We are running configure from the src root.
17249     # Create a default ./build/target-variant-debuglevel output root.
17250     if test "x${CONF_NAME}" = x; then
17251       { $as_echo "$as_me:${as_lineno-$LINENO}: result: in default location" >&5
17252 $as_echo "in default location" >&6; }
17253       CONF_NAME="${OPENJDK_TARGET_OS}-${OPENJDK_TARGET_CPU}-${JDK_VARIANT}-${JVM_VARIANTS_WITH_AND}-${DEBUG_LEVEL}"
17254     else
17255       { $as_echo "$as_me:${as_lineno-$LINENO}: result: in build directory with custom name" >&5
17256 $as_echo "in build directory with custom name" >&6; }
17257     fi
17258     OUTPUT_ROOT="$SRC_ROOT/build/${CONF_NAME}"
17259     $MKDIR -p "$OUTPUT_ROOT"
17260     if test ! -d "$OUTPUT_ROOT"; then
17261       as_fn_error $? "Could not create build directory $OUTPUT_ROOT" "$LINENO" 5
17262     fi
17263   else
17264     # We are running configure from outside of the src dir.
17265     # Then use the current directory as output dir!
17266     # If configuration is situated in normal build directory, just use the build
17267     # directory name as configuration name, otherwise use the complete path.
17268     if test "x${CONF_NAME}" = x; then
17269       CONF_NAME=`$ECHO $CURDIR | $SED -e "s!^${SRC_ROOT}/build/!!"`
17270     fi
17271     OUTPUT_ROOT="$CURDIR"
17272     { $as_echo "$as_me:${as_lineno-$LINENO}: result: in current directory" >&5
17273 $as_echo "in current directory" >&6; }
17274 
17275     # WARNING: This might be a bad thing to do. You need to be sure you want to
17276     # have a configuration in this directory. Do some sanity checks!
17277 
17278     if test ! -e "$OUTPUT_ROOT/spec.gmk"; then
17279       # If we have a spec.gmk, we have run here before and we are OK. Otherwise, check for
17280       # other files
17281       files_present=`$LS $OUTPUT_ROOT`
17282       # Configure has already touched config.log and confdefs.h in the current dir when this check
17283       # is performed.
17284       filtered_files=`$ECHO "$files_present" \
17285           | $SED -e 's/config.log//g' \
17286               -e 's/configure.log//g' \
17287               -e 's/confdefs.h//g' \
17288               -e 's/ //g' \
17289           | $TR -d '\n'`
17290       if test "x$filtered_files" != x; then
17291         { $as_echo "$as_me:${as_lineno-$LINENO}: Current directory is $CURDIR." >&5
17292 $as_echo "$as_me: Current directory is $CURDIR." >&6;}
17293         { $as_echo "$as_me:${as_lineno-$LINENO}: Since this is not the source root, configure will output the configuration here" >&5
17294 $as_echo "$as_me: Since this is not the source root, configure will output the configuration here" >&6;}
17295         { $as_echo "$as_me:${as_lineno-$LINENO}: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&5
17296 $as_echo "$as_me: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&6;}
17297         { $as_echo "$as_me:${as_lineno-$LINENO}: However, this directory is not empty. This is not allowed, since it could" >&5
17298 $as_echo "$as_me: However, this directory is not empty. This is not allowed, since it could" >&6;}
17299         { $as_echo "$as_me:${as_lineno-$LINENO}: seriously mess up just about everything." >&5
17300 $as_echo "$as_me: seriously mess up just about everything." >&6;}
17301         { $as_echo "$as_me:${as_lineno-$LINENO}: Try 'cd $SRC_ROOT' and restart configure" >&5
17302 $as_echo "$as_me: Try 'cd $SRC_ROOT' and restart configure" >&6;}
17303         { $as_echo "$as_me:${as_lineno-$LINENO}: (or create a new empty directory and cd to it)." >&5
17304 $as_echo "$as_me: (or create a new empty directory and cd to it)." >&6;}
17305         as_fn_error $? "Will not continue creating configuration in $CURDIR" "$LINENO" 5
17306       fi
17307     fi
17308   fi
17309   { $as_echo "$as_me:${as_lineno-$LINENO}: checking what configuration name to use" >&5
17310 $as_echo_n "checking what configuration name to use... " >&6; }
17311   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CONF_NAME" >&5
17312 $as_echo "$CONF_NAME" >&6; }
17313 
17314 
17315   # Only process if variable expands to non-empty
17316 
17317   if test "x$OUTPUT_ROOT" != x; then
17318     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17319 
17320   # Input might be given as Windows format, start by converting to
17321   # unix format.
17322   path="$OUTPUT_ROOT"
17323   new_path=`$CYGPATH -u "$path"`
17324 
17325   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
17326   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
17327   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
17328   # "foo.exe" is OK but "foo" is an error.
17329   #
17330   # This test is therefore slightly more accurate than "test -f" to check for file precense.
17331   # It is also a way to make sure we got the proper file name for the real test later on.
17332   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
17333   if test "x$test_shortpath" = x; then
17334     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&5
17335 $as_echo "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&6;}
17336     as_fn_error $? "Cannot locate the the path of OUTPUT_ROOT" "$LINENO" 5
17337   fi
17338 
17339   # Call helper function which possibly converts this using DOS-style short mode.
17340   # If so, the updated path is stored in $new_path.
17341 
17342   input_path="$new_path"
17343   # Check if we need to convert this using DOS-style short mode. If the path
17344   # contains just simple characters, use it. Otherwise (spaces, weird characters),
17345   # take no chances and rewrite it.
17346   # Note: m4 eats our [], so we need to use [ and ] instead.
17347   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
17348   if test "x$has_forbidden_chars" != x; then
17349     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
17350     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
17351     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
17352     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
17353       # Going to short mode and back again did indeed matter. Since short mode is
17354       # case insensitive, let's make it lowercase to improve readability.
17355       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
17356       # Now convert it back to Unix-style (cygpath)
17357       input_path=`$CYGPATH -u "$shortmode_path"`
17358       new_path="$input_path"
17359     fi
17360   fi
17361 
17362   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
17363   if test "x$test_cygdrive_prefix" = x; then
17364     # As a simple fix, exclude /usr/bin since it's not a real path.
17365     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
17366       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
17367       # a path prefixed by /cygdrive for fixpath to work.
17368       new_path="$CYGWIN_ROOT_PATH$input_path"
17369     fi
17370   fi
17371 
17372 
17373   if test "x$path" != "x$new_path"; then
17374     OUTPUT_ROOT="$new_path"
17375     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
17376 $as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
17377   fi
17378 
17379     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17380 
17381   path="$OUTPUT_ROOT"
17382   has_colon=`$ECHO $path | $GREP ^.:`
17383   new_path="$path"
17384   if test "x$has_colon" = x; then
17385     # Not in mixed or Windows style, start by that.
17386     new_path=`cmd //c echo $path`
17387   fi
17388 
17389 
17390   input_path="$new_path"
17391   # Check if we need to convert this using DOS-style short mode. If the path
17392   # contains just simple characters, use it. Otherwise (spaces, weird characters),
17393   # take no chances and rewrite it.
17394   # Note: m4 eats our [], so we need to use [ and ] instead.
17395   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
17396   if test "x$has_forbidden_chars" != x; then
17397     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
17398     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
17399   fi
17400 
17401 
17402   windows_path="$new_path"
17403   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17404     unix_path=`$CYGPATH -u "$windows_path"`
17405     new_path="$unix_path"
17406   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17407     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17408     new_path="$unix_path"
17409   fi
17410 
17411   if test "x$path" != "x$new_path"; then
17412     OUTPUT_ROOT="$new_path"
17413     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
17414 $as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
17415   fi
17416 
17417   # Save the first 10 bytes of this path to the storage, so fixpath can work.
17418   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
17419 
17420     else
17421       # We're on a unix platform. Hooray! :)
17422       path="$OUTPUT_ROOT"
17423       has_space=`$ECHO "$path" | $GREP " "`
17424       if test "x$has_space" != x; then
17425         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&5
17426 $as_echo "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&6;}
17427         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
17428       fi
17429 
17430       # Use eval to expand a potential ~
17431       eval path="$path"
17432       if test ! -f "$path" && test ! -d "$path"; then
17433         as_fn_error $? "The path of OUTPUT_ROOT, which resolves as \"$path\", is not found." "$LINENO" 5
17434       fi
17435 
17436       if test -d "$path"; then
17437         OUTPUT_ROOT="`cd "$path"; $THEPWDCMD -L`"
17438       else
17439         dir="`$DIRNAME "$path"`"
17440         base="`$BASENAME "$path"`"
17441         OUTPUT_ROOT="`cd "$dir"; $THEPWDCMD -L`/$base"
17442       fi
17443     fi
17444   fi
17445 
17446 
17447   CONFIGURESUPPORT_OUTPUTDIR="$OUTPUT_ROOT/configure-support"
17448   $MKDIR -p "$CONFIGURESUPPORT_OUTPUTDIR"
17449 
17450   SPEC=$OUTPUT_ROOT/spec.gmk
17451 
17452   CONF_NAME=$CONF_NAME
17453 
17454   OUTPUT_ROOT=$OUTPUT_ROOT
17455 
17456 
17457 
17458   # The spec.gmk file contains all variables for the make system.
17459   ac_config_files="$ac_config_files $OUTPUT_ROOT/spec.gmk:$AUTOCONF_DIR/spec.gmk.in"
17460 
17461   # The bootcycle-spec.gmk file contains support for boot cycle builds.
17462   ac_config_files="$ac_config_files $OUTPUT_ROOT/bootcycle-spec.gmk:$AUTOCONF_DIR/bootcycle-spec.gmk.in"
17463 
17464   # The buildjdk-spec.gmk file contains support for building a buildjdk when cross compiling.
17465   ac_config_files="$ac_config_files $OUTPUT_ROOT/buildjdk-spec.gmk:$AUTOCONF_DIR/buildjdk-spec.gmk.in"
17466 
17467   # The compare.sh is used to compare the build output to other builds.
17468   ac_config_files="$ac_config_files $OUTPUT_ROOT/compare.sh:$AUTOCONF_DIR/compare.sh.in"
17469 
17470   # The generated Makefile knows where the spec.gmk is and where the source is.
17471   # You can run make from the OUTPUT_ROOT, or from the top-level Makefile
17472   # which will look for generated configurations
17473   ac_config_files="$ac_config_files $OUTPUT_ROOT/Makefile:$AUTOCONF_DIR/Makefile.in"
17474 
17475 
17476 
17477 # Must be done before we can call HELP_MSG_MISSING_DEPENDENCY.
17478 
17479   for ac_prog in apt-get yum port pkgutil pkgadd
17480 do
17481   # Extract the first word of "$ac_prog", so it can be a program name with args.
17482 set dummy $ac_prog; ac_word=$2
17483 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17484 $as_echo_n "checking for $ac_word... " >&6; }
17485 if ${ac_cv_prog_PKGHANDLER+:} false; then :
17486   $as_echo_n "(cached) " >&6
17487 else
17488   if test -n "$PKGHANDLER"; then
17489   ac_cv_prog_PKGHANDLER="$PKGHANDLER" # Let the user override the test.
17490 else
17491 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17492 for as_dir in $PATH
17493 do
17494   IFS=$as_save_IFS
17495   test -z "$as_dir" && as_dir=.
17496     for ac_exec_ext in '' $ac_executable_extensions; do
17497   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17498     ac_cv_prog_PKGHANDLER="$ac_prog"
17499     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17500     break 2
17501   fi
17502 done
17503   done
17504 IFS=$as_save_IFS
17505 
17506 fi
17507 fi
17508 PKGHANDLER=$ac_cv_prog_PKGHANDLER
17509 if test -n "$PKGHANDLER"; then
17510   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKGHANDLER" >&5
17511 $as_echo "$PKGHANDLER" >&6; }
17512 else
17513   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17514 $as_echo "no" >&6; }
17515 fi
17516 
17517 
17518   test -n "$PKGHANDLER" && break
17519 done
17520 
17521 
17522 
17523 # Setup tools that requires more complex handling, or that is not needed by the configure script.
17524 
17525 
17526 
17527   # Publish this variable in the help.
17528 
17529 
17530   if [ -z "${MAKE+x}" ]; then
17531     # The variable is not set by user, try to locate tool using the code snippet
17532 
17533     # Try our hardest to locate a correct version of GNU make
17534     for ac_prog in gmake
17535 do
17536   # Extract the first word of "$ac_prog", so it can be a program name with args.
17537 set dummy $ac_prog; ac_word=$2
17538 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17539 $as_echo_n "checking for $ac_word... " >&6; }
17540 if ${ac_cv_path_CHECK_GMAKE+:} false; then :
17541   $as_echo_n "(cached) " >&6
17542 else
17543   case $CHECK_GMAKE in
17544   [\\/]* | ?:[\\/]*)
17545   ac_cv_path_CHECK_GMAKE="$CHECK_GMAKE" # Let the user override the test with a path.
17546   ;;
17547   *)
17548   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17549 for as_dir in $PATH
17550 do
17551   IFS=$as_save_IFS
17552   test -z "$as_dir" && as_dir=.
17553     for ac_exec_ext in '' $ac_executable_extensions; do
17554   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17555     ac_cv_path_CHECK_GMAKE="$as_dir/$ac_word$ac_exec_ext"
17556     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17557     break 2
17558   fi
17559 done
17560   done
17561 IFS=$as_save_IFS
17562 
17563   ;;
17564 esac
17565 fi
17566 CHECK_GMAKE=$ac_cv_path_CHECK_GMAKE
17567 if test -n "$CHECK_GMAKE"; then
17568   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_GMAKE" >&5
17569 $as_echo "$CHECK_GMAKE" >&6; }
17570 else
17571   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17572 $as_echo "no" >&6; }
17573 fi
17574 
17575 
17576   test -n "$CHECK_GMAKE" && break
17577 done
17578 
17579 
17580   MAKE_CANDIDATE=""$CHECK_GMAKE""
17581   DESCRIPTION="gmake in PATH"
17582 
17583   # On Cygwin, we require a newer version of make than on other platforms
17584   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17585     MAKE_VERSION_EXPR="-e 4\."
17586     MAKE_REQUIRED_VERSION="4.0"
17587    else
17588     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
17589     MAKE_REQUIRED_VERSION="3.81"
17590   fi
17591 
17592   if test "x$MAKE_CANDIDATE" != x; then
17593     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
17594 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
17595     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
17596     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
17597     if test "x$IS_GNU_MAKE" = x; then
17598       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
17599 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
17600     else
17601       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
17602       if test "x$IS_MODERN_MAKE" = x; then
17603         { $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
17604 $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;}
17605       else
17606         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
17607           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17608             MAKE_EXPECTED_ENV='cygwin'
17609           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17610             MAKE_EXPECTED_ENV='msys'
17611           else
17612             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
17613           fi
17614           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
17615           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
17616         else
17617           # Not relevant for non-Windows
17618           IS_MAKE_CORRECT_ENV=true
17619         fi
17620         if test "x$IS_MAKE_CORRECT_ENV" = x; then
17621           { $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
17622 $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;}
17623         else
17624           FOUND_MAKE=$MAKE_CANDIDATE
17625 
17626   # Only process if variable expands to non-empty
17627 
17628   if test "x$FOUND_MAKE" != x; then
17629     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17630 
17631   # First separate the path from the arguments. This will split at the first
17632   # space.
17633   complete="$FOUND_MAKE"
17634   path="${complete%% *}"
17635   tmp="$complete EOL"
17636   arguments="${tmp#* }"
17637 
17638   # Input might be given as Windows format, start by converting to
17639   # unix format.
17640   new_path=`$CYGPATH -u "$path"`
17641 
17642   # Now try to locate executable using which
17643   new_path=`$WHICH "$new_path" 2> /dev/null`
17644   # bat and cmd files are not always considered executable in cygwin causing which
17645   # to not find them
17646   if test "x$new_path" = x \
17647       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17648       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17649     new_path=`$CYGPATH -u "$path"`
17650   fi
17651   if test "x$new_path" = x; then
17652     # Oops. Which didn't find the executable.
17653     # The splitting of arguments from the executable at a space might have been incorrect,
17654     # since paths with space are more likely in Windows. Give it another try with the whole
17655     # argument.
17656     path="$complete"
17657     arguments="EOL"
17658     new_path=`$CYGPATH -u "$path"`
17659     new_path=`$WHICH "$new_path" 2> /dev/null`
17660     # bat and cmd files are not always considered executable in cygwin causing which
17661     # to not find them
17662     if test "x$new_path" = x \
17663         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17664         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17665       new_path=`$CYGPATH -u "$path"`
17666     fi
17667     if test "x$new_path" = x; then
17668       # It's still not found. Now this is an unrecoverable error.
17669       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17670 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17671       has_space=`$ECHO "$complete" | $GREP " "`
17672       if test "x$has_space" != x; then
17673         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
17674 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
17675       fi
17676       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17677     fi
17678   fi
17679 
17680   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
17681   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
17682   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
17683   # "foo.exe" is OK but "foo" is an error.
17684   #
17685   # This test is therefore slightly more accurate than "test -f" to check for file presence.
17686   # It is also a way to make sure we got the proper file name for the real test later on.
17687   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
17688   if test "x$test_shortpath" = x; then
17689     # Short path failed, file does not exist as specified.
17690     # Try adding .exe or .cmd
17691     if test -f "${new_path}.exe"; then
17692       input_to_shortpath="${new_path}.exe"
17693     elif test -f "${new_path}.cmd"; then
17694       input_to_shortpath="${new_path}.cmd"
17695     else
17696       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
17697 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
17698       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
17699 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
17700       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17701     fi
17702   else
17703     input_to_shortpath="$new_path"
17704   fi
17705 
17706   # Call helper function which possibly converts this using DOS-style short mode.
17707   # If so, the updated path is stored in $new_path.
17708   new_path="$input_to_shortpath"
17709 
17710   input_path="$input_to_shortpath"
17711   # Check if we need to convert this using DOS-style short mode. If the path
17712   # contains just simple characters, use it. Otherwise (spaces, weird characters),
17713   # take no chances and rewrite it.
17714   # Note: m4 eats our [], so we need to use [ and ] instead.
17715   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
17716   if test "x$has_forbidden_chars" != x; then
17717     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
17718     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
17719     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
17720     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
17721       # Going to short mode and back again did indeed matter. Since short mode is
17722       # case insensitive, let's make it lowercase to improve readability.
17723       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
17724       # Now convert it back to Unix-style (cygpath)
17725       input_path=`$CYGPATH -u "$shortmode_path"`
17726       new_path="$input_path"
17727     fi
17728   fi
17729 
17730   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
17731   if test "x$test_cygdrive_prefix" = x; then
17732     # As a simple fix, exclude /usr/bin since it's not a real path.
17733     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
17734       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
17735       # a path prefixed by /cygdrive for fixpath to work.
17736       new_path="$CYGWIN_ROOT_PATH$input_path"
17737     fi
17738   fi
17739 
17740   # remove trailing .exe if any
17741   new_path="${new_path/%.exe/}"
17742 
17743     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17744 
17745   # First separate the path from the arguments. This will split at the first
17746   # space.
17747   complete="$FOUND_MAKE"
17748   path="${complete%% *}"
17749   tmp="$complete EOL"
17750   arguments="${tmp#* }"
17751 
17752   # Input might be given as Windows format, start by converting to
17753   # unix format.
17754   new_path="$path"
17755 
17756   windows_path="$new_path"
17757   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17758     unix_path=`$CYGPATH -u "$windows_path"`
17759     new_path="$unix_path"
17760   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17761     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17762     new_path="$unix_path"
17763   fi
17764 
17765 
17766   # Now try to locate executable using which
17767   new_path=`$WHICH "$new_path" 2> /dev/null`
17768 
17769   if test "x$new_path" = x; then
17770     # Oops. Which didn't find the executable.
17771     # The splitting of arguments from the executable at a space might have been incorrect,
17772     # since paths with space are more likely in Windows. Give it another try with the whole
17773     # argument.
17774     path="$complete"
17775     arguments="EOL"
17776     new_path="$path"
17777 
17778   windows_path="$new_path"
17779   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17780     unix_path=`$CYGPATH -u "$windows_path"`
17781     new_path="$unix_path"
17782   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17783     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17784     new_path="$unix_path"
17785   fi
17786 
17787 
17788     new_path=`$WHICH "$new_path" 2> /dev/null`
17789     # bat and cmd files are not always considered executable in MSYS causing which
17790     # to not find them
17791     if test "x$new_path" = x \
17792         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17793         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17794       new_path="$path"
17795 
17796   windows_path="$new_path"
17797   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17798     unix_path=`$CYGPATH -u "$windows_path"`
17799     new_path="$unix_path"
17800   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17801     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17802     new_path="$unix_path"
17803   fi
17804 
17805     fi
17806 
17807     if test "x$new_path" = x; then
17808       # It's still not found. Now this is an unrecoverable error.
17809       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17810 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17811       has_space=`$ECHO "$complete" | $GREP " "`
17812       if test "x$has_space" != x; then
17813         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
17814 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
17815       fi
17816       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17817     fi
17818   fi
17819 
17820   # Now new_path has a complete unix path to the binary
17821   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
17822     # Keep paths in /bin as-is, but remove trailing .exe if any
17823     new_path="${new_path/%.exe/}"
17824     # Do not save /bin paths to all_fixpath_prefixes!
17825   else
17826     # Not in mixed or Windows style, start by that.
17827     new_path=`cmd //c echo $new_path`
17828 
17829   input_path="$new_path"
17830   # Check if we need to convert this using DOS-style short mode. If the path
17831   # contains just simple characters, use it. Otherwise (spaces, weird characters),
17832   # take no chances and rewrite it.
17833   # Note: m4 eats our [], so we need to use [ and ] instead.
17834   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
17835   if test "x$has_forbidden_chars" != x; then
17836     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
17837     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
17838   fi
17839 
17840     # Output is in $new_path
17841 
17842   windows_path="$new_path"
17843   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17844     unix_path=`$CYGPATH -u "$windows_path"`
17845     new_path="$unix_path"
17846   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17847     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17848     new_path="$unix_path"
17849   fi
17850 
17851     # remove trailing .exe if any
17852     new_path="${new_path/%.exe/}"
17853 
17854     # Save the first 10 bytes of this path to the storage, so fixpath can work.
17855     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
17856   fi
17857 
17858     else
17859       # We're on a unix platform. Hooray! :)
17860       # First separate the path from the arguments. This will split at the first
17861       # space.
17862       complete="$FOUND_MAKE"
17863       path="${complete%% *}"
17864       tmp="$complete EOL"
17865       arguments="${tmp#* }"
17866 
17867       # Cannot rely on the command "which" here since it doesn't always work.
17868       is_absolute_path=`$ECHO "$path" | $GREP ^/`
17869       if test -z "$is_absolute_path"; then
17870         # Path to executable is not absolute. Find it.
17871         IFS_save="$IFS"
17872         IFS=:
17873         for p in $PATH; do
17874           if test -f "$p/$path" && test -x "$p/$path"; then
17875             new_path="$p/$path"
17876             break
17877           fi
17878         done
17879         IFS="$IFS_save"
17880       else
17881         # This is an absolute path, we can use it without further modifications.
17882         new_path="$path"
17883       fi
17884 
17885       if test "x$new_path" = x; then
17886         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17887 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17888         has_space=`$ECHO "$complete" | $GREP " "`
17889         if test "x$has_space" != x; then
17890           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
17891 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
17892         fi
17893         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17894       fi
17895     fi
17896 
17897     # Now join together the path and the arguments once again
17898     if test "x$arguments" != xEOL; then
17899       new_complete="$new_path ${arguments% *}"
17900     else
17901       new_complete="$new_path"
17902     fi
17903 
17904     if test "x$complete" != "x$new_complete"; then
17905       FOUND_MAKE="$new_complete"
17906       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
17907 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
17908     fi
17909   fi
17910 
17911         fi
17912       fi
17913     fi
17914   fi
17915 
17916 
17917     if test "x$FOUND_MAKE" = x; then
17918       for ac_prog in make
17919 do
17920   # Extract the first word of "$ac_prog", so it can be a program name with args.
17921 set dummy $ac_prog; ac_word=$2
17922 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17923 $as_echo_n "checking for $ac_word... " >&6; }
17924 if ${ac_cv_path_CHECK_MAKE+:} false; then :
17925   $as_echo_n "(cached) " >&6
17926 else
17927   case $CHECK_MAKE in
17928   [\\/]* | ?:[\\/]*)
17929   ac_cv_path_CHECK_MAKE="$CHECK_MAKE" # Let the user override the test with a path.
17930   ;;
17931   *)
17932   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17933 for as_dir in $PATH
17934 do
17935   IFS=$as_save_IFS
17936   test -z "$as_dir" && as_dir=.
17937     for ac_exec_ext in '' $ac_executable_extensions; do
17938   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17939     ac_cv_path_CHECK_MAKE="$as_dir/$ac_word$ac_exec_ext"
17940     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17941     break 2
17942   fi
17943 done
17944   done
17945 IFS=$as_save_IFS
17946 
17947   ;;
17948 esac
17949 fi
17950 CHECK_MAKE=$ac_cv_path_CHECK_MAKE
17951 if test -n "$CHECK_MAKE"; then
17952   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_MAKE" >&5
17953 $as_echo "$CHECK_MAKE" >&6; }
17954 else
17955   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17956 $as_echo "no" >&6; }
17957 fi
17958 
17959 
17960   test -n "$CHECK_MAKE" && break
17961 done
17962 
17963 
17964   MAKE_CANDIDATE=""$CHECK_MAKE""
17965   DESCRIPTION="make in PATH"
17966 
17967   # On Cygwin, we require a newer version of make than on other platforms
17968   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17969     MAKE_VERSION_EXPR="-e 4\."
17970     MAKE_REQUIRED_VERSION="4.0"
17971    else
17972     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
17973     MAKE_REQUIRED_VERSION="3.81"
17974   fi
17975 
17976   if test "x$MAKE_CANDIDATE" != x; then
17977     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
17978 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
17979     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
17980     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
17981     if test "x$IS_GNU_MAKE" = x; then
17982       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
17983 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
17984     else
17985       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
17986       if test "x$IS_MODERN_MAKE" = x; then
17987         { $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
17988 $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;}
17989       else
17990         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
17991           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17992             MAKE_EXPECTED_ENV='cygwin'
17993           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17994             MAKE_EXPECTED_ENV='msys'
17995           else
17996             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
17997           fi
17998           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
17999           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
18000         else
18001           # Not relevant for non-Windows
18002           IS_MAKE_CORRECT_ENV=true
18003         fi
18004         if test "x$IS_MAKE_CORRECT_ENV" = x; then
18005           { $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
18006 $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;}
18007         else
18008           FOUND_MAKE=$MAKE_CANDIDATE
18009 
18010   # Only process if variable expands to non-empty
18011 
18012   if test "x$FOUND_MAKE" != x; then
18013     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18014 
18015   # First separate the path from the arguments. This will split at the first
18016   # space.
18017   complete="$FOUND_MAKE"
18018   path="${complete%% *}"
18019   tmp="$complete EOL"
18020   arguments="${tmp#* }"
18021 
18022   # Input might be given as Windows format, start by converting to
18023   # unix format.
18024   new_path=`$CYGPATH -u "$path"`
18025 
18026   # Now try to locate executable using which
18027   new_path=`$WHICH "$new_path" 2> /dev/null`
18028   # bat and cmd files are not always considered executable in cygwin causing which
18029   # to not find them
18030   if test "x$new_path" = x \
18031       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18032       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18033     new_path=`$CYGPATH -u "$path"`
18034   fi
18035   if test "x$new_path" = x; then
18036     # Oops. Which didn't find the executable.
18037     # The splitting of arguments from the executable at a space might have been incorrect,
18038     # since paths with space are more likely in Windows. Give it another try with the whole
18039     # argument.
18040     path="$complete"
18041     arguments="EOL"
18042     new_path=`$CYGPATH -u "$path"`
18043     new_path=`$WHICH "$new_path" 2> /dev/null`
18044     # bat and cmd files are not always considered executable in cygwin causing which
18045     # to not find them
18046     if test "x$new_path" = x \
18047         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18048         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18049       new_path=`$CYGPATH -u "$path"`
18050     fi
18051     if test "x$new_path" = x; then
18052       # It's still not found. Now this is an unrecoverable error.
18053       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18054 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18055       has_space=`$ECHO "$complete" | $GREP " "`
18056       if test "x$has_space" != x; then
18057         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
18058 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
18059       fi
18060       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18061     fi
18062   fi
18063 
18064   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
18065   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
18066   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
18067   # "foo.exe" is OK but "foo" is an error.
18068   #
18069   # This test is therefore slightly more accurate than "test -f" to check for file presence.
18070   # It is also a way to make sure we got the proper file name for the real test later on.
18071   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
18072   if test "x$test_shortpath" = x; then
18073     # Short path failed, file does not exist as specified.
18074     # Try adding .exe or .cmd
18075     if test -f "${new_path}.exe"; then
18076       input_to_shortpath="${new_path}.exe"
18077     elif test -f "${new_path}.cmd"; then
18078       input_to_shortpath="${new_path}.cmd"
18079     else
18080       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
18081 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
18082       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
18083 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
18084       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18085     fi
18086   else
18087     input_to_shortpath="$new_path"
18088   fi
18089 
18090   # Call helper function which possibly converts this using DOS-style short mode.
18091   # If so, the updated path is stored in $new_path.
18092   new_path="$input_to_shortpath"
18093 
18094   input_path="$input_to_shortpath"
18095   # Check if we need to convert this using DOS-style short mode. If the path
18096   # contains just simple characters, use it. Otherwise (spaces, weird characters),
18097   # take no chances and rewrite it.
18098   # Note: m4 eats our [], so we need to use [ and ] instead.
18099   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
18100   if test "x$has_forbidden_chars" != x; then
18101     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
18102     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
18103     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
18104     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
18105       # Going to short mode and back again did indeed matter. Since short mode is
18106       # case insensitive, let's make it lowercase to improve readability.
18107       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
18108       # Now convert it back to Unix-style (cygpath)
18109       input_path=`$CYGPATH -u "$shortmode_path"`
18110       new_path="$input_path"
18111     fi
18112   fi
18113 
18114   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
18115   if test "x$test_cygdrive_prefix" = x; then
18116     # As a simple fix, exclude /usr/bin since it's not a real path.
18117     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
18118       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
18119       # a path prefixed by /cygdrive for fixpath to work.
18120       new_path="$CYGWIN_ROOT_PATH$input_path"
18121     fi
18122   fi
18123 
18124   # remove trailing .exe if any
18125   new_path="${new_path/%.exe/}"
18126 
18127     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18128 
18129   # First separate the path from the arguments. This will split at the first
18130   # space.
18131   complete="$FOUND_MAKE"
18132   path="${complete%% *}"
18133   tmp="$complete EOL"
18134   arguments="${tmp#* }"
18135 
18136   # Input might be given as Windows format, start by converting to
18137   # unix format.
18138   new_path="$path"
18139 
18140   windows_path="$new_path"
18141   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18142     unix_path=`$CYGPATH -u "$windows_path"`
18143     new_path="$unix_path"
18144   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18145     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18146     new_path="$unix_path"
18147   fi
18148 
18149 
18150   # Now try to locate executable using which
18151   new_path=`$WHICH "$new_path" 2> /dev/null`
18152 
18153   if test "x$new_path" = x; then
18154     # Oops. Which didn't find the executable.
18155     # The splitting of arguments from the executable at a space might have been incorrect,
18156     # since paths with space are more likely in Windows. Give it another try with the whole
18157     # argument.
18158     path="$complete"
18159     arguments="EOL"
18160     new_path="$path"
18161 
18162   windows_path="$new_path"
18163   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18164     unix_path=`$CYGPATH -u "$windows_path"`
18165     new_path="$unix_path"
18166   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18167     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18168     new_path="$unix_path"
18169   fi
18170 
18171 
18172     new_path=`$WHICH "$new_path" 2> /dev/null`
18173     # bat and cmd files are not always considered executable in MSYS causing which
18174     # to not find them
18175     if test "x$new_path" = x \
18176         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18177         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18178       new_path="$path"
18179 
18180   windows_path="$new_path"
18181   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18182     unix_path=`$CYGPATH -u "$windows_path"`
18183     new_path="$unix_path"
18184   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18185     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18186     new_path="$unix_path"
18187   fi
18188 
18189     fi
18190 
18191     if test "x$new_path" = x; then
18192       # It's still not found. Now this is an unrecoverable error.
18193       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18194 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18195       has_space=`$ECHO "$complete" | $GREP " "`
18196       if test "x$has_space" != x; then
18197         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
18198 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
18199       fi
18200       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18201     fi
18202   fi
18203 
18204   # Now new_path has a complete unix path to the binary
18205   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
18206     # Keep paths in /bin as-is, but remove trailing .exe if any
18207     new_path="${new_path/%.exe/}"
18208     # Do not save /bin paths to all_fixpath_prefixes!
18209   else
18210     # Not in mixed or Windows style, start by that.
18211     new_path=`cmd //c echo $new_path`
18212 
18213   input_path="$new_path"
18214   # Check if we need to convert this using DOS-style short mode. If the path
18215   # contains just simple characters, use it. Otherwise (spaces, weird characters),
18216   # take no chances and rewrite it.
18217   # Note: m4 eats our [], so we need to use [ and ] instead.
18218   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
18219   if test "x$has_forbidden_chars" != x; then
18220     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
18221     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
18222   fi
18223 
18224     # Output is in $new_path
18225 
18226   windows_path="$new_path"
18227   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18228     unix_path=`$CYGPATH -u "$windows_path"`
18229     new_path="$unix_path"
18230   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18231     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18232     new_path="$unix_path"
18233   fi
18234 
18235     # remove trailing .exe if any
18236     new_path="${new_path/%.exe/}"
18237 
18238     # Save the first 10 bytes of this path to the storage, so fixpath can work.
18239     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
18240   fi
18241 
18242     else
18243       # We're on a unix platform. Hooray! :)
18244       # First separate the path from the arguments. This will split at the first
18245       # space.
18246       complete="$FOUND_MAKE"
18247       path="${complete%% *}"
18248       tmp="$complete EOL"
18249       arguments="${tmp#* }"
18250 
18251       # Cannot rely on the command "which" here since it doesn't always work.
18252       is_absolute_path=`$ECHO "$path" | $GREP ^/`
18253       if test -z "$is_absolute_path"; then
18254         # Path to executable is not absolute. Find it.
18255         IFS_save="$IFS"
18256         IFS=:
18257         for p in $PATH; do
18258           if test -f "$p/$path" && test -x "$p/$path"; then
18259             new_path="$p/$path"
18260             break
18261           fi
18262         done
18263         IFS="$IFS_save"
18264       else
18265         # This is an absolute path, we can use it without further modifications.
18266         new_path="$path"
18267       fi
18268 
18269       if test "x$new_path" = x; then
18270         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18271 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18272         has_space=`$ECHO "$complete" | $GREP " "`
18273         if test "x$has_space" != x; then
18274           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
18275 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
18276         fi
18277         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18278       fi
18279     fi
18280 
18281     # Now join together the path and the arguments once again
18282     if test "x$arguments" != xEOL; then
18283       new_complete="$new_path ${arguments% *}"
18284     else
18285       new_complete="$new_path"
18286     fi
18287 
18288     if test "x$complete" != "x$new_complete"; then
18289       FOUND_MAKE="$new_complete"
18290       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
18291 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
18292     fi
18293   fi
18294 
18295         fi
18296       fi
18297     fi
18298   fi
18299 
18300     fi
18301 
18302     if test "x$FOUND_MAKE" = x; then
18303       if test "x$TOOLCHAIN_PATH" != x; then
18304         # We have a toolchain path, check that as well before giving up.
18305         OLD_PATH=$PATH
18306         PATH=$TOOLCHAIN_PATH:$PATH
18307         for ac_prog in gmake
18308 do
18309   # Extract the first word of "$ac_prog", so it can be a program name with args.
18310 set dummy $ac_prog; ac_word=$2
18311 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18312 $as_echo_n "checking for $ac_word... " >&6; }
18313 if ${ac_cv_path_CHECK_TOOLSDIR_GMAKE+:} false; then :
18314   $as_echo_n "(cached) " >&6
18315 else
18316   case $CHECK_TOOLSDIR_GMAKE in
18317   [\\/]* | ?:[\\/]*)
18318   ac_cv_path_CHECK_TOOLSDIR_GMAKE="$CHECK_TOOLSDIR_GMAKE" # Let the user override the test with a path.
18319   ;;
18320   *)
18321   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18322 for as_dir in $PATH
18323 do
18324   IFS=$as_save_IFS
18325   test -z "$as_dir" && as_dir=.
18326     for ac_exec_ext in '' $ac_executable_extensions; do
18327   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18328     ac_cv_path_CHECK_TOOLSDIR_GMAKE="$as_dir/$ac_word$ac_exec_ext"
18329     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18330     break 2
18331   fi
18332 done
18333   done
18334 IFS=$as_save_IFS
18335 
18336   ;;
18337 esac
18338 fi
18339 CHECK_TOOLSDIR_GMAKE=$ac_cv_path_CHECK_TOOLSDIR_GMAKE
18340 if test -n "$CHECK_TOOLSDIR_GMAKE"; then
18341   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_GMAKE" >&5
18342 $as_echo "$CHECK_TOOLSDIR_GMAKE" >&6; }
18343 else
18344   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18345 $as_echo "no" >&6; }
18346 fi
18347 
18348 
18349   test -n "$CHECK_TOOLSDIR_GMAKE" && break
18350 done
18351 
18352 
18353   MAKE_CANDIDATE=""$CHECK_TOOLSDIR_GMAKE""
18354   DESCRIPTION="gmake in tools-dir"
18355 
18356   # On Cygwin, we require a newer version of make than on other platforms
18357   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18358     MAKE_VERSION_EXPR="-e 4\."
18359     MAKE_REQUIRED_VERSION="4.0"
18360    else
18361     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
18362     MAKE_REQUIRED_VERSION="3.81"
18363   fi
18364 
18365   if test "x$MAKE_CANDIDATE" != x; then
18366     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
18367 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
18368     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
18369     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
18370     if test "x$IS_GNU_MAKE" = x; then
18371       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
18372 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
18373     else
18374       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
18375       if test "x$IS_MODERN_MAKE" = x; then
18376         { $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
18377 $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;}
18378       else
18379         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
18380           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18381             MAKE_EXPECTED_ENV='cygwin'
18382           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18383             MAKE_EXPECTED_ENV='msys'
18384           else
18385             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
18386           fi
18387           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
18388           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
18389         else
18390           # Not relevant for non-Windows
18391           IS_MAKE_CORRECT_ENV=true
18392         fi
18393         if test "x$IS_MAKE_CORRECT_ENV" = x; then
18394           { $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
18395 $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;}
18396         else
18397           FOUND_MAKE=$MAKE_CANDIDATE
18398 
18399   # Only process if variable expands to non-empty
18400 
18401   if test "x$FOUND_MAKE" != x; then
18402     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18403 
18404   # First separate the path from the arguments. This will split at the first
18405   # space.
18406   complete="$FOUND_MAKE"
18407   path="${complete%% *}"
18408   tmp="$complete EOL"
18409   arguments="${tmp#* }"
18410 
18411   # Input might be given as Windows format, start by converting to
18412   # unix format.
18413   new_path=`$CYGPATH -u "$path"`
18414 
18415   # Now try to locate executable using which
18416   new_path=`$WHICH "$new_path" 2> /dev/null`
18417   # bat and cmd files are not always considered executable in cygwin causing which
18418   # to not find them
18419   if test "x$new_path" = x \
18420       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18421       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18422     new_path=`$CYGPATH -u "$path"`
18423   fi
18424   if test "x$new_path" = x; then
18425     # Oops. Which didn't find the executable.
18426     # The splitting of arguments from the executable at a space might have been incorrect,
18427     # since paths with space are more likely in Windows. Give it another try with the whole
18428     # argument.
18429     path="$complete"
18430     arguments="EOL"
18431     new_path=`$CYGPATH -u "$path"`
18432     new_path=`$WHICH "$new_path" 2> /dev/null`
18433     # bat and cmd files are not always considered executable in cygwin causing which
18434     # to not find them
18435     if test "x$new_path" = x \
18436         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18437         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18438       new_path=`$CYGPATH -u "$path"`
18439     fi
18440     if test "x$new_path" = x; then
18441       # It's still not found. Now this is an unrecoverable error.
18442       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18443 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18444       has_space=`$ECHO "$complete" | $GREP " "`
18445       if test "x$has_space" != x; then
18446         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
18447 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
18448       fi
18449       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18450     fi
18451   fi
18452 
18453   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
18454   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
18455   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
18456   # "foo.exe" is OK but "foo" is an error.
18457   #
18458   # This test is therefore slightly more accurate than "test -f" to check for file presence.
18459   # It is also a way to make sure we got the proper file name for the real test later on.
18460   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
18461   if test "x$test_shortpath" = x; then
18462     # Short path failed, file does not exist as specified.
18463     # Try adding .exe or .cmd
18464     if test -f "${new_path}.exe"; then
18465       input_to_shortpath="${new_path}.exe"
18466     elif test -f "${new_path}.cmd"; then
18467       input_to_shortpath="${new_path}.cmd"
18468     else
18469       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
18470 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
18471       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
18472 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
18473       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18474     fi
18475   else
18476     input_to_shortpath="$new_path"
18477   fi
18478 
18479   # Call helper function which possibly converts this using DOS-style short mode.
18480   # If so, the updated path is stored in $new_path.
18481   new_path="$input_to_shortpath"
18482 
18483   input_path="$input_to_shortpath"
18484   # Check if we need to convert this using DOS-style short mode. If the path
18485   # contains just simple characters, use it. Otherwise (spaces, weird characters),
18486   # take no chances and rewrite it.
18487   # Note: m4 eats our [], so we need to use [ and ] instead.
18488   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
18489   if test "x$has_forbidden_chars" != x; then
18490     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
18491     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
18492     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
18493     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
18494       # Going to short mode and back again did indeed matter. Since short mode is
18495       # case insensitive, let's make it lowercase to improve readability.
18496       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
18497       # Now convert it back to Unix-style (cygpath)
18498       input_path=`$CYGPATH -u "$shortmode_path"`
18499       new_path="$input_path"
18500     fi
18501   fi
18502 
18503   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
18504   if test "x$test_cygdrive_prefix" = x; then
18505     # As a simple fix, exclude /usr/bin since it's not a real path.
18506     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
18507       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
18508       # a path prefixed by /cygdrive for fixpath to work.
18509       new_path="$CYGWIN_ROOT_PATH$input_path"
18510     fi
18511   fi
18512 
18513   # remove trailing .exe if any
18514   new_path="${new_path/%.exe/}"
18515 
18516     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18517 
18518   # First separate the path from the arguments. This will split at the first
18519   # space.
18520   complete="$FOUND_MAKE"
18521   path="${complete%% *}"
18522   tmp="$complete EOL"
18523   arguments="${tmp#* }"
18524 
18525   # Input might be given as Windows format, start by converting to
18526   # unix format.
18527   new_path="$path"
18528 
18529   windows_path="$new_path"
18530   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18531     unix_path=`$CYGPATH -u "$windows_path"`
18532     new_path="$unix_path"
18533   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18534     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18535     new_path="$unix_path"
18536   fi
18537 
18538 
18539   # Now try to locate executable using which
18540   new_path=`$WHICH "$new_path" 2> /dev/null`
18541 
18542   if test "x$new_path" = x; then
18543     # Oops. Which didn't find the executable.
18544     # The splitting of arguments from the executable at a space might have been incorrect,
18545     # since paths with space are more likely in Windows. Give it another try with the whole
18546     # argument.
18547     path="$complete"
18548     arguments="EOL"
18549     new_path="$path"
18550 
18551   windows_path="$new_path"
18552   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18553     unix_path=`$CYGPATH -u "$windows_path"`
18554     new_path="$unix_path"
18555   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18556     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18557     new_path="$unix_path"
18558   fi
18559 
18560 
18561     new_path=`$WHICH "$new_path" 2> /dev/null`
18562     # bat and cmd files are not always considered executable in MSYS causing which
18563     # to not find them
18564     if test "x$new_path" = x \
18565         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18566         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18567       new_path="$path"
18568 
18569   windows_path="$new_path"
18570   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18571     unix_path=`$CYGPATH -u "$windows_path"`
18572     new_path="$unix_path"
18573   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18574     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18575     new_path="$unix_path"
18576   fi
18577 
18578     fi
18579 
18580     if test "x$new_path" = x; then
18581       # It's still not found. Now this is an unrecoverable error.
18582       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18583 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18584       has_space=`$ECHO "$complete" | $GREP " "`
18585       if test "x$has_space" != x; then
18586         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
18587 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
18588       fi
18589       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18590     fi
18591   fi
18592 
18593   # Now new_path has a complete unix path to the binary
18594   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
18595     # Keep paths in /bin as-is, but remove trailing .exe if any
18596     new_path="${new_path/%.exe/}"
18597     # Do not save /bin paths to all_fixpath_prefixes!
18598   else
18599     # Not in mixed or Windows style, start by that.
18600     new_path=`cmd //c echo $new_path`
18601 
18602   input_path="$new_path"
18603   # Check if we need to convert this using DOS-style short mode. If the path
18604   # contains just simple characters, use it. Otherwise (spaces, weird characters),
18605   # take no chances and rewrite it.
18606   # Note: m4 eats our [], so we need to use [ and ] instead.
18607   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
18608   if test "x$has_forbidden_chars" != x; then
18609     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
18610     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
18611   fi
18612 
18613     # Output is in $new_path
18614 
18615   windows_path="$new_path"
18616   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18617     unix_path=`$CYGPATH -u "$windows_path"`
18618     new_path="$unix_path"
18619   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18620     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18621     new_path="$unix_path"
18622   fi
18623 
18624     # remove trailing .exe if any
18625     new_path="${new_path/%.exe/}"
18626 
18627     # Save the first 10 bytes of this path to the storage, so fixpath can work.
18628     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
18629   fi
18630 
18631     else
18632       # We're on a unix platform. Hooray! :)
18633       # First separate the path from the arguments. This will split at the first
18634       # space.
18635       complete="$FOUND_MAKE"
18636       path="${complete%% *}"
18637       tmp="$complete EOL"
18638       arguments="${tmp#* }"
18639 
18640       # Cannot rely on the command "which" here since it doesn't always work.
18641       is_absolute_path=`$ECHO "$path" | $GREP ^/`
18642       if test -z "$is_absolute_path"; then
18643         # Path to executable is not absolute. Find it.
18644         IFS_save="$IFS"
18645         IFS=:
18646         for p in $PATH; do
18647           if test -f "$p/$path" && test -x "$p/$path"; then
18648             new_path="$p/$path"
18649             break
18650           fi
18651         done
18652         IFS="$IFS_save"
18653       else
18654         # This is an absolute path, we can use it without further modifications.
18655         new_path="$path"
18656       fi
18657 
18658       if test "x$new_path" = x; then
18659         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18660 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18661         has_space=`$ECHO "$complete" | $GREP " "`
18662         if test "x$has_space" != x; then
18663           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
18664 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
18665         fi
18666         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18667       fi
18668     fi
18669 
18670     # Now join together the path and the arguments once again
18671     if test "x$arguments" != xEOL; then
18672       new_complete="$new_path ${arguments% *}"
18673     else
18674       new_complete="$new_path"
18675     fi
18676 
18677     if test "x$complete" != "x$new_complete"; then
18678       FOUND_MAKE="$new_complete"
18679       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
18680 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
18681     fi
18682   fi
18683 
18684         fi
18685       fi
18686     fi
18687   fi
18688 
18689         if test "x$FOUND_MAKE" = x; then
18690           for ac_prog in make
18691 do
18692   # Extract the first word of "$ac_prog", so it can be a program name with args.
18693 set dummy $ac_prog; ac_word=$2
18694 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18695 $as_echo_n "checking for $ac_word... " >&6; }
18696 if ${ac_cv_path_CHECK_TOOLSDIR_MAKE+:} false; then :
18697   $as_echo_n "(cached) " >&6
18698 else
18699   case $CHECK_TOOLSDIR_MAKE in
18700   [\\/]* | ?:[\\/]*)
18701   ac_cv_path_CHECK_TOOLSDIR_MAKE="$CHECK_TOOLSDIR_MAKE" # Let the user override the test with a path.
18702   ;;
18703   *)
18704   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18705 for as_dir in $PATH
18706 do
18707   IFS=$as_save_IFS
18708   test -z "$as_dir" && as_dir=.
18709     for ac_exec_ext in '' $ac_executable_extensions; do
18710   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18711     ac_cv_path_CHECK_TOOLSDIR_MAKE="$as_dir/$ac_word$ac_exec_ext"
18712     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18713     break 2
18714   fi
18715 done
18716   done
18717 IFS=$as_save_IFS
18718 
18719   ;;
18720 esac
18721 fi
18722 CHECK_TOOLSDIR_MAKE=$ac_cv_path_CHECK_TOOLSDIR_MAKE
18723 if test -n "$CHECK_TOOLSDIR_MAKE"; then
18724   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_MAKE" >&5
18725 $as_echo "$CHECK_TOOLSDIR_MAKE" >&6; }
18726 else
18727   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18728 $as_echo "no" >&6; }
18729 fi
18730 
18731 
18732   test -n "$CHECK_TOOLSDIR_MAKE" && break
18733 done
18734 
18735 
18736   MAKE_CANDIDATE=""$CHECK_TOOLSDIR_MAKE""
18737   DESCRIPTION="make in tools-dir"
18738 
18739   # On Cygwin, we require a newer version of make than on other platforms
18740   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18741     MAKE_VERSION_EXPR="-e 4\."
18742     MAKE_REQUIRED_VERSION="4.0"
18743    else
18744     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
18745     MAKE_REQUIRED_VERSION="3.81"
18746   fi
18747 
18748   if test "x$MAKE_CANDIDATE" != x; then
18749     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
18750 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
18751     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
18752     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
18753     if test "x$IS_GNU_MAKE" = x; then
18754       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
18755 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
18756     else
18757       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
18758       if test "x$IS_MODERN_MAKE" = x; then
18759         { $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
18760 $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;}
18761       else
18762         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
18763           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18764             MAKE_EXPECTED_ENV='cygwin'
18765           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18766             MAKE_EXPECTED_ENV='msys'
18767           else
18768             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
18769           fi
18770           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
18771           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
18772         else
18773           # Not relevant for non-Windows
18774           IS_MAKE_CORRECT_ENV=true
18775         fi
18776         if test "x$IS_MAKE_CORRECT_ENV" = x; then
18777           { $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
18778 $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;}
18779         else
18780           FOUND_MAKE=$MAKE_CANDIDATE
18781 
18782   # Only process if variable expands to non-empty
18783 
18784   if test "x$FOUND_MAKE" != x; then
18785     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18786 
18787   # First separate the path from the arguments. This will split at the first
18788   # space.
18789   complete="$FOUND_MAKE"
18790   path="${complete%% *}"
18791   tmp="$complete EOL"
18792   arguments="${tmp#* }"
18793 
18794   # Input might be given as Windows format, start by converting to
18795   # unix format.
18796   new_path=`$CYGPATH -u "$path"`
18797 
18798   # Now try to locate executable using which
18799   new_path=`$WHICH "$new_path" 2> /dev/null`
18800   # bat and cmd files are not always considered executable in cygwin causing which
18801   # to not find them
18802   if test "x$new_path" = x \
18803       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18804       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18805     new_path=`$CYGPATH -u "$path"`
18806   fi
18807   if test "x$new_path" = x; then
18808     # Oops. Which didn't find the executable.
18809     # The splitting of arguments from the executable at a space might have been incorrect,
18810     # since paths with space are more likely in Windows. Give it another try with the whole
18811     # argument.
18812     path="$complete"
18813     arguments="EOL"
18814     new_path=`$CYGPATH -u "$path"`
18815     new_path=`$WHICH "$new_path" 2> /dev/null`
18816     # bat and cmd files are not always considered executable in cygwin causing which
18817     # to not find them
18818     if test "x$new_path" = x \
18819         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18820         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18821       new_path=`$CYGPATH -u "$path"`
18822     fi
18823     if test "x$new_path" = x; then
18824       # It's still not found. Now this is an unrecoverable error.
18825       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18826 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18827       has_space=`$ECHO "$complete" | $GREP " "`
18828       if test "x$has_space" != x; then
18829         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
18830 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
18831       fi
18832       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18833     fi
18834   fi
18835 
18836   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
18837   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
18838   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
18839   # "foo.exe" is OK but "foo" is an error.
18840   #
18841   # This test is therefore slightly more accurate than "test -f" to check for file presence.
18842   # It is also a way to make sure we got the proper file name for the real test later on.
18843   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
18844   if test "x$test_shortpath" = x; then
18845     # Short path failed, file does not exist as specified.
18846     # Try adding .exe or .cmd
18847     if test -f "${new_path}.exe"; then
18848       input_to_shortpath="${new_path}.exe"
18849     elif test -f "${new_path}.cmd"; then
18850       input_to_shortpath="${new_path}.cmd"
18851     else
18852       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
18853 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
18854       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
18855 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
18856       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18857     fi
18858   else
18859     input_to_shortpath="$new_path"
18860   fi
18861 
18862   # Call helper function which possibly converts this using DOS-style short mode.
18863   # If so, the updated path is stored in $new_path.
18864   new_path="$input_to_shortpath"
18865 
18866   input_path="$input_to_shortpath"
18867   # Check if we need to convert this using DOS-style short mode. If the path
18868   # contains just simple characters, use it. Otherwise (spaces, weird characters),
18869   # take no chances and rewrite it.
18870   # Note: m4 eats our [], so we need to use [ and ] instead.
18871   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
18872   if test "x$has_forbidden_chars" != x; then
18873     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
18874     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
18875     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
18876     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
18877       # Going to short mode and back again did indeed matter. Since short mode is
18878       # case insensitive, let's make it lowercase to improve readability.
18879       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
18880       # Now convert it back to Unix-style (cygpath)
18881       input_path=`$CYGPATH -u "$shortmode_path"`
18882       new_path="$input_path"
18883     fi
18884   fi
18885 
18886   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
18887   if test "x$test_cygdrive_prefix" = x; then
18888     # As a simple fix, exclude /usr/bin since it's not a real path.
18889     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
18890       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
18891       # a path prefixed by /cygdrive for fixpath to work.
18892       new_path="$CYGWIN_ROOT_PATH$input_path"
18893     fi
18894   fi
18895 
18896   # remove trailing .exe if any
18897   new_path="${new_path/%.exe/}"
18898 
18899     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18900 
18901   # First separate the path from the arguments. This will split at the first
18902   # space.
18903   complete="$FOUND_MAKE"
18904   path="${complete%% *}"
18905   tmp="$complete EOL"
18906   arguments="${tmp#* }"
18907 
18908   # Input might be given as Windows format, start by converting to
18909   # unix format.
18910   new_path="$path"
18911 
18912   windows_path="$new_path"
18913   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18914     unix_path=`$CYGPATH -u "$windows_path"`
18915     new_path="$unix_path"
18916   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18917     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18918     new_path="$unix_path"
18919   fi
18920 
18921 
18922   # Now try to locate executable using which
18923   new_path=`$WHICH "$new_path" 2> /dev/null`
18924 
18925   if test "x$new_path" = x; then
18926     # Oops. Which didn't find the executable.
18927     # The splitting of arguments from the executable at a space might have been incorrect,
18928     # since paths with space are more likely in Windows. Give it another try with the whole
18929     # argument.
18930     path="$complete"
18931     arguments="EOL"
18932     new_path="$path"
18933 
18934   windows_path="$new_path"
18935   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18936     unix_path=`$CYGPATH -u "$windows_path"`
18937     new_path="$unix_path"
18938   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18939     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18940     new_path="$unix_path"
18941   fi
18942 
18943 
18944     new_path=`$WHICH "$new_path" 2> /dev/null`
18945     # bat and cmd files are not always considered executable in MSYS causing which
18946     # to not find them
18947     if test "x$new_path" = x \
18948         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18949         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18950       new_path="$path"
18951 
18952   windows_path="$new_path"
18953   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18954     unix_path=`$CYGPATH -u "$windows_path"`
18955     new_path="$unix_path"
18956   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18957     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18958     new_path="$unix_path"
18959   fi
18960 
18961     fi
18962 
18963     if test "x$new_path" = x; then
18964       # It's still not found. Now this is an unrecoverable error.
18965       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18966 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18967       has_space=`$ECHO "$complete" | $GREP " "`
18968       if test "x$has_space" != x; then
18969         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
18970 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
18971       fi
18972       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18973     fi
18974   fi
18975 
18976   # Now new_path has a complete unix path to the binary
18977   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
18978     # Keep paths in /bin as-is, but remove trailing .exe if any
18979     new_path="${new_path/%.exe/}"
18980     # Do not save /bin paths to all_fixpath_prefixes!
18981   else
18982     # Not in mixed or Windows style, start by that.
18983     new_path=`cmd //c echo $new_path`
18984 
18985   input_path="$new_path"
18986   # Check if we need to convert this using DOS-style short mode. If the path
18987   # contains just simple characters, use it. Otherwise (spaces, weird characters),
18988   # take no chances and rewrite it.
18989   # Note: m4 eats our [], so we need to use [ and ] instead.
18990   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
18991   if test "x$has_forbidden_chars" != x; then
18992     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
18993     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
18994   fi
18995 
18996     # Output is in $new_path
18997 
18998   windows_path="$new_path"
18999   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19000     unix_path=`$CYGPATH -u "$windows_path"`
19001     new_path="$unix_path"
19002   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19003     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19004     new_path="$unix_path"
19005   fi
19006 
19007     # remove trailing .exe if any
19008     new_path="${new_path/%.exe/}"
19009 
19010     # Save the first 10 bytes of this path to the storage, so fixpath can work.
19011     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
19012   fi
19013 
19014     else
19015       # We're on a unix platform. Hooray! :)
19016       # First separate the path from the arguments. This will split at the first
19017       # space.
19018       complete="$FOUND_MAKE"
19019       path="${complete%% *}"
19020       tmp="$complete EOL"
19021       arguments="${tmp#* }"
19022 
19023       # Cannot rely on the command "which" here since it doesn't always work.
19024       is_absolute_path=`$ECHO "$path" | $GREP ^/`
19025       if test -z "$is_absolute_path"; then
19026         # Path to executable is not absolute. Find it.
19027         IFS_save="$IFS"
19028         IFS=:
19029         for p in $PATH; do
19030           if test -f "$p/$path" && test -x "$p/$path"; then
19031             new_path="$p/$path"
19032             break
19033           fi
19034         done
19035         IFS="$IFS_save"
19036       else
19037         # This is an absolute path, we can use it without further modifications.
19038         new_path="$path"
19039       fi
19040 
19041       if test "x$new_path" = x; then
19042         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19043 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19044         has_space=`$ECHO "$complete" | $GREP " "`
19045         if test "x$has_space" != x; then
19046           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
19047 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
19048         fi
19049         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19050       fi
19051     fi
19052 
19053     # Now join together the path and the arguments once again
19054     if test "x$arguments" != xEOL; then
19055       new_complete="$new_path ${arguments% *}"
19056     else
19057       new_complete="$new_path"
19058     fi
19059 
19060     if test "x$complete" != "x$new_complete"; then
19061       FOUND_MAKE="$new_complete"
19062       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
19063 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
19064     fi
19065   fi
19066 
19067         fi
19068       fi
19069     fi
19070   fi
19071 
19072         fi
19073         PATH=$OLD_PATH
19074       fi
19075     fi
19076 
19077     if test "x$FOUND_MAKE" = x; then
19078       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
19079     fi
19080 
19081   else
19082     # The variable is set, but is it from the command line or the environment?
19083 
19084     # Try to remove the string !MAKE! from our list.
19085     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MAKE!/}
19086     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
19087       # If it failed, the variable was not from the command line. Ignore it,
19088       # but warn the user (except for BASH, which is always set by the calling BASH).
19089       if test "xMAKE" != xBASH; then
19090         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MAKE from the environment. Use command line variables instead." >&5
19091 $as_echo "$as_me: WARNING: Ignoring value of MAKE from the environment. Use command line variables instead." >&2;}
19092       fi
19093       # Try to locate tool using the code snippet
19094 
19095     # Try our hardest to locate a correct version of GNU make
19096     for ac_prog in gmake
19097 do
19098   # Extract the first word of "$ac_prog", so it can be a program name with args.
19099 set dummy $ac_prog; ac_word=$2
19100 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19101 $as_echo_n "checking for $ac_word... " >&6; }
19102 if ${ac_cv_path_CHECK_GMAKE+:} false; then :
19103   $as_echo_n "(cached) " >&6
19104 else
19105   case $CHECK_GMAKE in
19106   [\\/]* | ?:[\\/]*)
19107   ac_cv_path_CHECK_GMAKE="$CHECK_GMAKE" # Let the user override the test with a path.
19108   ;;
19109   *)
19110   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19111 for as_dir in $PATH
19112 do
19113   IFS=$as_save_IFS
19114   test -z "$as_dir" && as_dir=.
19115     for ac_exec_ext in '' $ac_executable_extensions; do
19116   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19117     ac_cv_path_CHECK_GMAKE="$as_dir/$ac_word$ac_exec_ext"
19118     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19119     break 2
19120   fi
19121 done
19122   done
19123 IFS=$as_save_IFS
19124 
19125   ;;
19126 esac
19127 fi
19128 CHECK_GMAKE=$ac_cv_path_CHECK_GMAKE
19129 if test -n "$CHECK_GMAKE"; then
19130   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_GMAKE" >&5
19131 $as_echo "$CHECK_GMAKE" >&6; }
19132 else
19133   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19134 $as_echo "no" >&6; }
19135 fi
19136 
19137 
19138   test -n "$CHECK_GMAKE" && break
19139 done
19140 
19141 
19142   MAKE_CANDIDATE=""$CHECK_GMAKE""
19143   DESCRIPTION="gmake in PATH"
19144 
19145   # On Cygwin, we require a newer version of make than on other platforms
19146   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19147     MAKE_VERSION_EXPR="-e 4\."
19148     MAKE_REQUIRED_VERSION="4.0"
19149    else
19150     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
19151     MAKE_REQUIRED_VERSION="3.81"
19152   fi
19153 
19154   if test "x$MAKE_CANDIDATE" != x; then
19155     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
19156 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
19157     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
19158     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
19159     if test "x$IS_GNU_MAKE" = x; then
19160       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
19161 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
19162     else
19163       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
19164       if test "x$IS_MODERN_MAKE" = x; then
19165         { $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
19166 $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;}
19167       else
19168         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
19169           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19170             MAKE_EXPECTED_ENV='cygwin'
19171           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19172             MAKE_EXPECTED_ENV='msys'
19173           else
19174             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
19175           fi
19176           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
19177           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
19178         else
19179           # Not relevant for non-Windows
19180           IS_MAKE_CORRECT_ENV=true
19181         fi
19182         if test "x$IS_MAKE_CORRECT_ENV" = x; then
19183           { $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
19184 $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;}
19185         else
19186           FOUND_MAKE=$MAKE_CANDIDATE
19187 
19188   # Only process if variable expands to non-empty
19189 
19190   if test "x$FOUND_MAKE" != x; then
19191     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19192 
19193   # First separate the path from the arguments. This will split at the first
19194   # space.
19195   complete="$FOUND_MAKE"
19196   path="${complete%% *}"
19197   tmp="$complete EOL"
19198   arguments="${tmp#* }"
19199 
19200   # Input might be given as Windows format, start by converting to
19201   # unix format.
19202   new_path=`$CYGPATH -u "$path"`
19203 
19204   # Now try to locate executable using which
19205   new_path=`$WHICH "$new_path" 2> /dev/null`
19206   # bat and cmd files are not always considered executable in cygwin causing which
19207   # to not find them
19208   if test "x$new_path" = x \
19209       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19210       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19211     new_path=`$CYGPATH -u "$path"`
19212   fi
19213   if test "x$new_path" = x; then
19214     # Oops. Which didn't find the executable.
19215     # The splitting of arguments from the executable at a space might have been incorrect,
19216     # since paths with space are more likely in Windows. Give it another try with the whole
19217     # argument.
19218     path="$complete"
19219     arguments="EOL"
19220     new_path=`$CYGPATH -u "$path"`
19221     new_path=`$WHICH "$new_path" 2> /dev/null`
19222     # bat and cmd files are not always considered executable in cygwin causing which
19223     # to not find them
19224     if test "x$new_path" = x \
19225         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19226         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19227       new_path=`$CYGPATH -u "$path"`
19228     fi
19229     if test "x$new_path" = x; then
19230       # It's still not found. Now this is an unrecoverable error.
19231       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19232 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19233       has_space=`$ECHO "$complete" | $GREP " "`
19234       if test "x$has_space" != x; then
19235         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
19236 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
19237       fi
19238       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19239     fi
19240   fi
19241 
19242   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
19243   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
19244   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
19245   # "foo.exe" is OK but "foo" is an error.
19246   #
19247   # This test is therefore slightly more accurate than "test -f" to check for file presence.
19248   # It is also a way to make sure we got the proper file name for the real test later on.
19249   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
19250   if test "x$test_shortpath" = x; then
19251     # Short path failed, file does not exist as specified.
19252     # Try adding .exe or .cmd
19253     if test -f "${new_path}.exe"; then
19254       input_to_shortpath="${new_path}.exe"
19255     elif test -f "${new_path}.cmd"; then
19256       input_to_shortpath="${new_path}.cmd"
19257     else
19258       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
19259 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
19260       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
19261 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
19262       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19263     fi
19264   else
19265     input_to_shortpath="$new_path"
19266   fi
19267 
19268   # Call helper function which possibly converts this using DOS-style short mode.
19269   # If so, the updated path is stored in $new_path.
19270   new_path="$input_to_shortpath"
19271 
19272   input_path="$input_to_shortpath"
19273   # Check if we need to convert this using DOS-style short mode. If the path
19274   # contains just simple characters, use it. Otherwise (spaces, weird characters),
19275   # take no chances and rewrite it.
19276   # Note: m4 eats our [], so we need to use [ and ] instead.
19277   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
19278   if test "x$has_forbidden_chars" != x; then
19279     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
19280     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
19281     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
19282     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
19283       # Going to short mode and back again did indeed matter. Since short mode is
19284       # case insensitive, let's make it lowercase to improve readability.
19285       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
19286       # Now convert it back to Unix-style (cygpath)
19287       input_path=`$CYGPATH -u "$shortmode_path"`
19288       new_path="$input_path"
19289     fi
19290   fi
19291 
19292   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
19293   if test "x$test_cygdrive_prefix" = x; then
19294     # As a simple fix, exclude /usr/bin since it's not a real path.
19295     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
19296       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
19297       # a path prefixed by /cygdrive for fixpath to work.
19298       new_path="$CYGWIN_ROOT_PATH$input_path"
19299     fi
19300   fi
19301 
19302   # remove trailing .exe if any
19303   new_path="${new_path/%.exe/}"
19304 
19305     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19306 
19307   # First separate the path from the arguments. This will split at the first
19308   # space.
19309   complete="$FOUND_MAKE"
19310   path="${complete%% *}"
19311   tmp="$complete EOL"
19312   arguments="${tmp#* }"
19313 
19314   # Input might be given as Windows format, start by converting to
19315   # unix format.
19316   new_path="$path"
19317 
19318   windows_path="$new_path"
19319   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19320     unix_path=`$CYGPATH -u "$windows_path"`
19321     new_path="$unix_path"
19322   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19323     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19324     new_path="$unix_path"
19325   fi
19326 
19327 
19328   # Now try to locate executable using which
19329   new_path=`$WHICH "$new_path" 2> /dev/null`
19330 
19331   if test "x$new_path" = x; then
19332     # Oops. Which didn't find the executable.
19333     # The splitting of arguments from the executable at a space might have been incorrect,
19334     # since paths with space are more likely in Windows. Give it another try with the whole
19335     # argument.
19336     path="$complete"
19337     arguments="EOL"
19338     new_path="$path"
19339 
19340   windows_path="$new_path"
19341   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19342     unix_path=`$CYGPATH -u "$windows_path"`
19343     new_path="$unix_path"
19344   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19345     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19346     new_path="$unix_path"
19347   fi
19348 
19349 
19350     new_path=`$WHICH "$new_path" 2> /dev/null`
19351     # bat and cmd files are not always considered executable in MSYS causing which
19352     # to not find them
19353     if test "x$new_path" = x \
19354         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19355         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19356       new_path="$path"
19357 
19358   windows_path="$new_path"
19359   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19360     unix_path=`$CYGPATH -u "$windows_path"`
19361     new_path="$unix_path"
19362   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19363     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19364     new_path="$unix_path"
19365   fi
19366 
19367     fi
19368 
19369     if test "x$new_path" = x; then
19370       # It's still not found. Now this is an unrecoverable error.
19371       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19372 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19373       has_space=`$ECHO "$complete" | $GREP " "`
19374       if test "x$has_space" != x; then
19375         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
19376 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
19377       fi
19378       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19379     fi
19380   fi
19381 
19382   # Now new_path has a complete unix path to the binary
19383   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
19384     # Keep paths in /bin as-is, but remove trailing .exe if any
19385     new_path="${new_path/%.exe/}"
19386     # Do not save /bin paths to all_fixpath_prefixes!
19387   else
19388     # Not in mixed or Windows style, start by that.
19389     new_path=`cmd //c echo $new_path`
19390 
19391   input_path="$new_path"
19392   # Check if we need to convert this using DOS-style short mode. If the path
19393   # contains just simple characters, use it. Otherwise (spaces, weird characters),
19394   # take no chances and rewrite it.
19395   # Note: m4 eats our [], so we need to use [ and ] instead.
19396   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
19397   if test "x$has_forbidden_chars" != x; then
19398     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
19399     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
19400   fi
19401 
19402     # Output is in $new_path
19403 
19404   windows_path="$new_path"
19405   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19406     unix_path=`$CYGPATH -u "$windows_path"`
19407     new_path="$unix_path"
19408   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19409     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19410     new_path="$unix_path"
19411   fi
19412 
19413     # remove trailing .exe if any
19414     new_path="${new_path/%.exe/}"
19415 
19416     # Save the first 10 bytes of this path to the storage, so fixpath can work.
19417     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
19418   fi
19419 
19420     else
19421       # We're on a unix platform. Hooray! :)
19422       # First separate the path from the arguments. This will split at the first
19423       # space.
19424       complete="$FOUND_MAKE"
19425       path="${complete%% *}"
19426       tmp="$complete EOL"
19427       arguments="${tmp#* }"
19428 
19429       # Cannot rely on the command "which" here since it doesn't always work.
19430       is_absolute_path=`$ECHO "$path" | $GREP ^/`
19431       if test -z "$is_absolute_path"; then
19432         # Path to executable is not absolute. Find it.
19433         IFS_save="$IFS"
19434         IFS=:
19435         for p in $PATH; do
19436           if test -f "$p/$path" && test -x "$p/$path"; then
19437             new_path="$p/$path"
19438             break
19439           fi
19440         done
19441         IFS="$IFS_save"
19442       else
19443         # This is an absolute path, we can use it without further modifications.
19444         new_path="$path"
19445       fi
19446 
19447       if test "x$new_path" = x; then
19448         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19449 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19450         has_space=`$ECHO "$complete" | $GREP " "`
19451         if test "x$has_space" != x; then
19452           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
19453 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
19454         fi
19455         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19456       fi
19457     fi
19458 
19459     # Now join together the path and the arguments once again
19460     if test "x$arguments" != xEOL; then
19461       new_complete="$new_path ${arguments% *}"
19462     else
19463       new_complete="$new_path"
19464     fi
19465 
19466     if test "x$complete" != "x$new_complete"; then
19467       FOUND_MAKE="$new_complete"
19468       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
19469 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
19470     fi
19471   fi
19472 
19473         fi
19474       fi
19475     fi
19476   fi
19477 
19478 
19479     if test "x$FOUND_MAKE" = x; then
19480       for ac_prog in make
19481 do
19482   # Extract the first word of "$ac_prog", so it can be a program name with args.
19483 set dummy $ac_prog; ac_word=$2
19484 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19485 $as_echo_n "checking for $ac_word... " >&6; }
19486 if ${ac_cv_path_CHECK_MAKE+:} false; then :
19487   $as_echo_n "(cached) " >&6
19488 else
19489   case $CHECK_MAKE in
19490   [\\/]* | ?:[\\/]*)
19491   ac_cv_path_CHECK_MAKE="$CHECK_MAKE" # Let the user override the test with a path.
19492   ;;
19493   *)
19494   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19495 for as_dir in $PATH
19496 do
19497   IFS=$as_save_IFS
19498   test -z "$as_dir" && as_dir=.
19499     for ac_exec_ext in '' $ac_executable_extensions; do
19500   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19501     ac_cv_path_CHECK_MAKE="$as_dir/$ac_word$ac_exec_ext"
19502     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19503     break 2
19504   fi
19505 done
19506   done
19507 IFS=$as_save_IFS
19508 
19509   ;;
19510 esac
19511 fi
19512 CHECK_MAKE=$ac_cv_path_CHECK_MAKE
19513 if test -n "$CHECK_MAKE"; then
19514   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_MAKE" >&5
19515 $as_echo "$CHECK_MAKE" >&6; }
19516 else
19517   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19518 $as_echo "no" >&6; }
19519 fi
19520 
19521 
19522   test -n "$CHECK_MAKE" && break
19523 done
19524 
19525 
19526   MAKE_CANDIDATE=""$CHECK_MAKE""
19527   DESCRIPTION="make in PATH"
19528 
19529   # On Cygwin, we require a newer version of make than on other platforms
19530   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19531     MAKE_VERSION_EXPR="-e 4\."
19532     MAKE_REQUIRED_VERSION="4.0"
19533    else
19534     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
19535     MAKE_REQUIRED_VERSION="3.81"
19536   fi
19537 
19538   if test "x$MAKE_CANDIDATE" != x; then
19539     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
19540 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
19541     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
19542     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
19543     if test "x$IS_GNU_MAKE" = x; then
19544       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
19545 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
19546     else
19547       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
19548       if test "x$IS_MODERN_MAKE" = x; then
19549         { $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
19550 $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;}
19551       else
19552         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
19553           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19554             MAKE_EXPECTED_ENV='cygwin'
19555           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19556             MAKE_EXPECTED_ENV='msys'
19557           else
19558             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
19559           fi
19560           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
19561           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
19562         else
19563           # Not relevant for non-Windows
19564           IS_MAKE_CORRECT_ENV=true
19565         fi
19566         if test "x$IS_MAKE_CORRECT_ENV" = x; then
19567           { $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
19568 $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;}
19569         else
19570           FOUND_MAKE=$MAKE_CANDIDATE
19571 
19572   # Only process if variable expands to non-empty
19573 
19574   if test "x$FOUND_MAKE" != x; then
19575     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19576 
19577   # First separate the path from the arguments. This will split at the first
19578   # space.
19579   complete="$FOUND_MAKE"
19580   path="${complete%% *}"
19581   tmp="$complete EOL"
19582   arguments="${tmp#* }"
19583 
19584   # Input might be given as Windows format, start by converting to
19585   # unix format.
19586   new_path=`$CYGPATH -u "$path"`
19587 
19588   # Now try to locate executable using which
19589   new_path=`$WHICH "$new_path" 2> /dev/null`
19590   # bat and cmd files are not always considered executable in cygwin causing which
19591   # to not find them
19592   if test "x$new_path" = x \
19593       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19594       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19595     new_path=`$CYGPATH -u "$path"`
19596   fi
19597   if test "x$new_path" = x; then
19598     # Oops. Which didn't find the executable.
19599     # The splitting of arguments from the executable at a space might have been incorrect,
19600     # since paths with space are more likely in Windows. Give it another try with the whole
19601     # argument.
19602     path="$complete"
19603     arguments="EOL"
19604     new_path=`$CYGPATH -u "$path"`
19605     new_path=`$WHICH "$new_path" 2> /dev/null`
19606     # bat and cmd files are not always considered executable in cygwin causing which
19607     # to not find them
19608     if test "x$new_path" = x \
19609         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19610         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19611       new_path=`$CYGPATH -u "$path"`
19612     fi
19613     if test "x$new_path" = x; then
19614       # It's still not found. Now this is an unrecoverable error.
19615       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19616 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19617       has_space=`$ECHO "$complete" | $GREP " "`
19618       if test "x$has_space" != x; then
19619         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
19620 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
19621       fi
19622       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19623     fi
19624   fi
19625 
19626   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
19627   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
19628   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
19629   # "foo.exe" is OK but "foo" is an error.
19630   #
19631   # This test is therefore slightly more accurate than "test -f" to check for file presence.
19632   # It is also a way to make sure we got the proper file name for the real test later on.
19633   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
19634   if test "x$test_shortpath" = x; then
19635     # Short path failed, file does not exist as specified.
19636     # Try adding .exe or .cmd
19637     if test -f "${new_path}.exe"; then
19638       input_to_shortpath="${new_path}.exe"
19639     elif test -f "${new_path}.cmd"; then
19640       input_to_shortpath="${new_path}.cmd"
19641     else
19642       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
19643 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
19644       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
19645 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
19646       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19647     fi
19648   else
19649     input_to_shortpath="$new_path"
19650   fi
19651 
19652   # Call helper function which possibly converts this using DOS-style short mode.
19653   # If so, the updated path is stored in $new_path.
19654   new_path="$input_to_shortpath"
19655 
19656   input_path="$input_to_shortpath"
19657   # Check if we need to convert this using DOS-style short mode. If the path
19658   # contains just simple characters, use it. Otherwise (spaces, weird characters),
19659   # take no chances and rewrite it.
19660   # Note: m4 eats our [], so we need to use [ and ] instead.
19661   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
19662   if test "x$has_forbidden_chars" != x; then
19663     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
19664     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
19665     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
19666     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
19667       # Going to short mode and back again did indeed matter. Since short mode is
19668       # case insensitive, let's make it lowercase to improve readability.
19669       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
19670       # Now convert it back to Unix-style (cygpath)
19671       input_path=`$CYGPATH -u "$shortmode_path"`
19672       new_path="$input_path"
19673     fi
19674   fi
19675 
19676   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
19677   if test "x$test_cygdrive_prefix" = x; then
19678     # As a simple fix, exclude /usr/bin since it's not a real path.
19679     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
19680       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
19681       # a path prefixed by /cygdrive for fixpath to work.
19682       new_path="$CYGWIN_ROOT_PATH$input_path"
19683     fi
19684   fi
19685 
19686   # remove trailing .exe if any
19687   new_path="${new_path/%.exe/}"
19688 
19689     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19690 
19691   # First separate the path from the arguments. This will split at the first
19692   # space.
19693   complete="$FOUND_MAKE"
19694   path="${complete%% *}"
19695   tmp="$complete EOL"
19696   arguments="${tmp#* }"
19697 
19698   # Input might be given as Windows format, start by converting to
19699   # unix format.
19700   new_path="$path"
19701 
19702   windows_path="$new_path"
19703   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19704     unix_path=`$CYGPATH -u "$windows_path"`
19705     new_path="$unix_path"
19706   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19707     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19708     new_path="$unix_path"
19709   fi
19710 
19711 
19712   # Now try to locate executable using which
19713   new_path=`$WHICH "$new_path" 2> /dev/null`
19714 
19715   if test "x$new_path" = x; then
19716     # Oops. Which didn't find the executable.
19717     # The splitting of arguments from the executable at a space might have been incorrect,
19718     # since paths with space are more likely in Windows. Give it another try with the whole
19719     # argument.
19720     path="$complete"
19721     arguments="EOL"
19722     new_path="$path"
19723 
19724   windows_path="$new_path"
19725   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19726     unix_path=`$CYGPATH -u "$windows_path"`
19727     new_path="$unix_path"
19728   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19729     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19730     new_path="$unix_path"
19731   fi
19732 
19733 
19734     new_path=`$WHICH "$new_path" 2> /dev/null`
19735     # bat and cmd files are not always considered executable in MSYS causing which
19736     # to not find them
19737     if test "x$new_path" = x \
19738         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19739         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19740       new_path="$path"
19741 
19742   windows_path="$new_path"
19743   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19744     unix_path=`$CYGPATH -u "$windows_path"`
19745     new_path="$unix_path"
19746   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19747     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19748     new_path="$unix_path"
19749   fi
19750 
19751     fi
19752 
19753     if test "x$new_path" = x; then
19754       # It's still not found. Now this is an unrecoverable error.
19755       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19756 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19757       has_space=`$ECHO "$complete" | $GREP " "`
19758       if test "x$has_space" != x; then
19759         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
19760 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
19761       fi
19762       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19763     fi
19764   fi
19765 
19766   # Now new_path has a complete unix path to the binary
19767   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
19768     # Keep paths in /bin as-is, but remove trailing .exe if any
19769     new_path="${new_path/%.exe/}"
19770     # Do not save /bin paths to all_fixpath_prefixes!
19771   else
19772     # Not in mixed or Windows style, start by that.
19773     new_path=`cmd //c echo $new_path`
19774 
19775   input_path="$new_path"
19776   # Check if we need to convert this using DOS-style short mode. If the path
19777   # contains just simple characters, use it. Otherwise (spaces, weird characters),
19778   # take no chances and rewrite it.
19779   # Note: m4 eats our [], so we need to use [ and ] instead.
19780   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
19781   if test "x$has_forbidden_chars" != x; then
19782     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
19783     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
19784   fi
19785 
19786     # Output is in $new_path
19787 
19788   windows_path="$new_path"
19789   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19790     unix_path=`$CYGPATH -u "$windows_path"`
19791     new_path="$unix_path"
19792   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19793     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19794     new_path="$unix_path"
19795   fi
19796 
19797     # remove trailing .exe if any
19798     new_path="${new_path/%.exe/}"
19799 
19800     # Save the first 10 bytes of this path to the storage, so fixpath can work.
19801     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
19802   fi
19803 
19804     else
19805       # We're on a unix platform. Hooray! :)
19806       # First separate the path from the arguments. This will split at the first
19807       # space.
19808       complete="$FOUND_MAKE"
19809       path="${complete%% *}"
19810       tmp="$complete EOL"
19811       arguments="${tmp#* }"
19812 
19813       # Cannot rely on the command "which" here since it doesn't always work.
19814       is_absolute_path=`$ECHO "$path" | $GREP ^/`
19815       if test -z "$is_absolute_path"; then
19816         # Path to executable is not absolute. Find it.
19817         IFS_save="$IFS"
19818         IFS=:
19819         for p in $PATH; do
19820           if test -f "$p/$path" && test -x "$p/$path"; then
19821             new_path="$p/$path"
19822             break
19823           fi
19824         done
19825         IFS="$IFS_save"
19826       else
19827         # This is an absolute path, we can use it without further modifications.
19828         new_path="$path"
19829       fi
19830 
19831       if test "x$new_path" = x; then
19832         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19833 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19834         has_space=`$ECHO "$complete" | $GREP " "`
19835         if test "x$has_space" != x; then
19836           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
19837 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
19838         fi
19839         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19840       fi
19841     fi
19842 
19843     # Now join together the path and the arguments once again
19844     if test "x$arguments" != xEOL; then
19845       new_complete="$new_path ${arguments% *}"
19846     else
19847       new_complete="$new_path"
19848     fi
19849 
19850     if test "x$complete" != "x$new_complete"; then
19851       FOUND_MAKE="$new_complete"
19852       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
19853 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
19854     fi
19855   fi
19856 
19857         fi
19858       fi
19859     fi
19860   fi
19861 
19862     fi
19863 
19864     if test "x$FOUND_MAKE" = x; then
19865       if test "x$TOOLCHAIN_PATH" != x; then
19866         # We have a toolchain path, check that as well before giving up.
19867         OLD_PATH=$PATH
19868         PATH=$TOOLCHAIN_PATH:$PATH
19869         for ac_prog in gmake
19870 do
19871   # Extract the first word of "$ac_prog", so it can be a program name with args.
19872 set dummy $ac_prog; ac_word=$2
19873 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19874 $as_echo_n "checking for $ac_word... " >&6; }
19875 if ${ac_cv_path_CHECK_TOOLSDIR_GMAKE+:} false; then :
19876   $as_echo_n "(cached) " >&6
19877 else
19878   case $CHECK_TOOLSDIR_GMAKE in
19879   [\\/]* | ?:[\\/]*)
19880   ac_cv_path_CHECK_TOOLSDIR_GMAKE="$CHECK_TOOLSDIR_GMAKE" # Let the user override the test with a path.
19881   ;;
19882   *)
19883   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19884 for as_dir in $PATH
19885 do
19886   IFS=$as_save_IFS
19887   test -z "$as_dir" && as_dir=.
19888     for ac_exec_ext in '' $ac_executable_extensions; do
19889   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19890     ac_cv_path_CHECK_TOOLSDIR_GMAKE="$as_dir/$ac_word$ac_exec_ext"
19891     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19892     break 2
19893   fi
19894 done
19895   done
19896 IFS=$as_save_IFS
19897 
19898   ;;
19899 esac
19900 fi
19901 CHECK_TOOLSDIR_GMAKE=$ac_cv_path_CHECK_TOOLSDIR_GMAKE
19902 if test -n "$CHECK_TOOLSDIR_GMAKE"; then
19903   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_GMAKE" >&5
19904 $as_echo "$CHECK_TOOLSDIR_GMAKE" >&6; }
19905 else
19906   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19907 $as_echo "no" >&6; }
19908 fi
19909 
19910 
19911   test -n "$CHECK_TOOLSDIR_GMAKE" && break
19912 done
19913 
19914 
19915   MAKE_CANDIDATE=""$CHECK_TOOLSDIR_GMAKE""
19916   DESCRIPTION="gmake in tools-dir"
19917 
19918   # On Cygwin, we require a newer version of make than on other platforms
19919   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19920     MAKE_VERSION_EXPR="-e 4\."
19921     MAKE_REQUIRED_VERSION="4.0"
19922    else
19923     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
19924     MAKE_REQUIRED_VERSION="3.81"
19925   fi
19926 
19927   if test "x$MAKE_CANDIDATE" != x; then
19928     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
19929 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
19930     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
19931     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
19932     if test "x$IS_GNU_MAKE" = x; then
19933       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
19934 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
19935     else
19936       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
19937       if test "x$IS_MODERN_MAKE" = x; then
19938         { $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
19939 $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;}
19940       else
19941         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
19942           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19943             MAKE_EXPECTED_ENV='cygwin'
19944           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19945             MAKE_EXPECTED_ENV='msys'
19946           else
19947             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
19948           fi
19949           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
19950           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
19951         else
19952           # Not relevant for non-Windows
19953           IS_MAKE_CORRECT_ENV=true
19954         fi
19955         if test "x$IS_MAKE_CORRECT_ENV" = x; then
19956           { $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
19957 $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;}
19958         else
19959           FOUND_MAKE=$MAKE_CANDIDATE
19960 
19961   # Only process if variable expands to non-empty
19962 
19963   if test "x$FOUND_MAKE" != x; then
19964     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19965 
19966   # First separate the path from the arguments. This will split at the first
19967   # space.
19968   complete="$FOUND_MAKE"
19969   path="${complete%% *}"
19970   tmp="$complete EOL"
19971   arguments="${tmp#* }"
19972 
19973   # Input might be given as Windows format, start by converting to
19974   # unix format.
19975   new_path=`$CYGPATH -u "$path"`
19976 
19977   # Now try to locate executable using which
19978   new_path=`$WHICH "$new_path" 2> /dev/null`
19979   # bat and cmd files are not always considered executable in cygwin causing which
19980   # to not find them
19981   if test "x$new_path" = x \
19982       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19983       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19984     new_path=`$CYGPATH -u "$path"`
19985   fi
19986   if test "x$new_path" = x; then
19987     # Oops. Which didn't find the executable.
19988     # The splitting of arguments from the executable at a space might have been incorrect,
19989     # since paths with space are more likely in Windows. Give it another try with the whole
19990     # argument.
19991     path="$complete"
19992     arguments="EOL"
19993     new_path=`$CYGPATH -u "$path"`
19994     new_path=`$WHICH "$new_path" 2> /dev/null`
19995     # bat and cmd files are not always considered executable in cygwin causing which
19996     # to not find them
19997     if test "x$new_path" = x \
19998         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19999         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
20000       new_path=`$CYGPATH -u "$path"`
20001     fi
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   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
20016   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
20017   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
20018   # "foo.exe" is OK but "foo" is an error.
20019   #
20020   # This test is therefore slightly more accurate than "test -f" to check for file presence.
20021   # It is also a way to make sure we got the proper file name for the real test later on.
20022   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
20023   if test "x$test_shortpath" = x; then
20024     # Short path failed, file does not exist as specified.
20025     # Try adding .exe or .cmd
20026     if test -f "${new_path}.exe"; then
20027       input_to_shortpath="${new_path}.exe"
20028     elif test -f "${new_path}.cmd"; then
20029       input_to_shortpath="${new_path}.cmd"
20030     else
20031       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
20032 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
20033       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
20034 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
20035       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
20036     fi
20037   else
20038     input_to_shortpath="$new_path"
20039   fi
20040 
20041   # Call helper function which possibly converts this using DOS-style short mode.
20042   # If so, the updated path is stored in $new_path.
20043   new_path="$input_to_shortpath"
20044 
20045   input_path="$input_to_shortpath"
20046   # Check if we need to convert this using DOS-style short mode. If the path
20047   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20048   # take no chances and rewrite it.
20049   # Note: m4 eats our [], so we need to use [ and ] instead.
20050   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20051   if test "x$has_forbidden_chars" != x; then
20052     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20053     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20054     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20055     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20056       # Going to short mode and back again did indeed matter. Since short mode is
20057       # case insensitive, let's make it lowercase to improve readability.
20058       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20059       # Now convert it back to Unix-style (cygpath)
20060       input_path=`$CYGPATH -u "$shortmode_path"`
20061       new_path="$input_path"
20062     fi
20063   fi
20064 
20065   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20066   if test "x$test_cygdrive_prefix" = x; then
20067     # As a simple fix, exclude /usr/bin since it's not a real path.
20068     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
20069       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20070       # a path prefixed by /cygdrive for fixpath to work.
20071       new_path="$CYGWIN_ROOT_PATH$input_path"
20072     fi
20073   fi
20074 
20075   # remove trailing .exe if any
20076   new_path="${new_path/%.exe/}"
20077 
20078     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20079 
20080   # First separate the path from the arguments. This will split at the first
20081   # space.
20082   complete="$FOUND_MAKE"
20083   path="${complete%% *}"
20084   tmp="$complete EOL"
20085   arguments="${tmp#* }"
20086 
20087   # Input might be given as Windows format, start by converting to
20088   # unix format.
20089   new_path="$path"
20090 
20091   windows_path="$new_path"
20092   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20093     unix_path=`$CYGPATH -u "$windows_path"`
20094     new_path="$unix_path"
20095   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20096     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20097     new_path="$unix_path"
20098   fi
20099 
20100 
20101   # Now try to locate executable using which
20102   new_path=`$WHICH "$new_path" 2> /dev/null`
20103 
20104   if test "x$new_path" = x; then
20105     # Oops. Which didn't find the executable.
20106     # The splitting of arguments from the executable at a space might have been incorrect,
20107     # since paths with space are more likely in Windows. Give it another try with the whole
20108     # argument.
20109     path="$complete"
20110     arguments="EOL"
20111     new_path="$path"
20112 
20113   windows_path="$new_path"
20114   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20115     unix_path=`$CYGPATH -u "$windows_path"`
20116     new_path="$unix_path"
20117   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20118     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20119     new_path="$unix_path"
20120   fi
20121 
20122 
20123     new_path=`$WHICH "$new_path" 2> /dev/null`
20124     # bat and cmd files are not always considered executable in MSYS causing which
20125     # to not find them
20126     if test "x$new_path" = x \
20127         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
20128         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
20129       new_path="$path"
20130 
20131   windows_path="$new_path"
20132   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20133     unix_path=`$CYGPATH -u "$windows_path"`
20134     new_path="$unix_path"
20135   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20136     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20137     new_path="$unix_path"
20138   fi
20139 
20140     fi
20141 
20142     if test "x$new_path" = x; then
20143       # It's still not found. Now this is an unrecoverable error.
20144       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
20145 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
20146       has_space=`$ECHO "$complete" | $GREP " "`
20147       if test "x$has_space" != x; then
20148         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
20149 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
20150       fi
20151       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
20152     fi
20153   fi
20154 
20155   # Now new_path has a complete unix path to the binary
20156   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
20157     # Keep paths in /bin as-is, but remove trailing .exe if any
20158     new_path="${new_path/%.exe/}"
20159     # Do not save /bin paths to all_fixpath_prefixes!
20160   else
20161     # Not in mixed or Windows style, start by that.
20162     new_path=`cmd //c echo $new_path`
20163 
20164   input_path="$new_path"
20165   # Check if we need to convert this using DOS-style short mode. If the path
20166   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20167   # take no chances and rewrite it.
20168   # Note: m4 eats our [], so we need to use [ and ] instead.
20169   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20170   if test "x$has_forbidden_chars" != x; then
20171     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20172     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20173   fi
20174 
20175     # Output is in $new_path
20176 
20177   windows_path="$new_path"
20178   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20179     unix_path=`$CYGPATH -u "$windows_path"`
20180     new_path="$unix_path"
20181   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20182     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20183     new_path="$unix_path"
20184   fi
20185 
20186     # remove trailing .exe if any
20187     new_path="${new_path/%.exe/}"
20188 
20189     # Save the first 10 bytes of this path to the storage, so fixpath can work.
20190     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20191   fi
20192 
20193     else
20194       # We're on a unix platform. Hooray! :)
20195       # First separate the path from the arguments. This will split at the first
20196       # space.
20197       complete="$FOUND_MAKE"
20198       path="${complete%% *}"
20199       tmp="$complete EOL"
20200       arguments="${tmp#* }"
20201 
20202       # Cannot rely on the command "which" here since it doesn't always work.
20203       is_absolute_path=`$ECHO "$path" | $GREP ^/`
20204       if test -z "$is_absolute_path"; then
20205         # Path to executable is not absolute. Find it.
20206         IFS_save="$IFS"
20207         IFS=:
20208         for p in $PATH; do
20209           if test -f "$p/$path" && test -x "$p/$path"; then
20210             new_path="$p/$path"
20211             break
20212           fi
20213         done
20214         IFS="$IFS_save"
20215       else
20216         # This is an absolute path, we can use it without further modifications.
20217         new_path="$path"
20218       fi
20219 
20220       if test "x$new_path" = x; then
20221         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
20222 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
20223         has_space=`$ECHO "$complete" | $GREP " "`
20224         if test "x$has_space" != x; then
20225           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
20226 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
20227         fi
20228         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
20229       fi
20230     fi
20231 
20232     # Now join together the path and the arguments once again
20233     if test "x$arguments" != xEOL; then
20234       new_complete="$new_path ${arguments% *}"
20235     else
20236       new_complete="$new_path"
20237     fi
20238 
20239     if test "x$complete" != "x$new_complete"; then
20240       FOUND_MAKE="$new_complete"
20241       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
20242 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
20243     fi
20244   fi
20245 
20246         fi
20247       fi
20248     fi
20249   fi
20250 
20251         if test "x$FOUND_MAKE" = x; then
20252           for ac_prog in make
20253 do
20254   # Extract the first word of "$ac_prog", so it can be a program name with args.
20255 set dummy $ac_prog; ac_word=$2
20256 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
20257 $as_echo_n "checking for $ac_word... " >&6; }
20258 if ${ac_cv_path_CHECK_TOOLSDIR_MAKE+:} false; then :
20259   $as_echo_n "(cached) " >&6
20260 else
20261   case $CHECK_TOOLSDIR_MAKE in
20262   [\\/]* | ?:[\\/]*)
20263   ac_cv_path_CHECK_TOOLSDIR_MAKE="$CHECK_TOOLSDIR_MAKE" # Let the user override the test with a path.
20264   ;;
20265   *)
20266   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
20267 for as_dir in $PATH
20268 do
20269   IFS=$as_save_IFS
20270   test -z "$as_dir" && as_dir=.
20271     for ac_exec_ext in '' $ac_executable_extensions; do
20272   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
20273     ac_cv_path_CHECK_TOOLSDIR_MAKE="$as_dir/$ac_word$ac_exec_ext"
20274     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
20275     break 2
20276   fi
20277 done
20278   done
20279 IFS=$as_save_IFS
20280 
20281   ;;
20282 esac
20283 fi
20284 CHECK_TOOLSDIR_MAKE=$ac_cv_path_CHECK_TOOLSDIR_MAKE
20285 if test -n "$CHECK_TOOLSDIR_MAKE"; then
20286   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_MAKE" >&5
20287 $as_echo "$CHECK_TOOLSDIR_MAKE" >&6; }
20288 else
20289   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20290 $as_echo "no" >&6; }
20291 fi
20292 
20293 
20294   test -n "$CHECK_TOOLSDIR_MAKE" && break
20295 done
20296 
20297 
20298   MAKE_CANDIDATE=""$CHECK_TOOLSDIR_MAKE""
20299   DESCRIPTION="make in tools-dir"
20300 
20301   # On Cygwin, we require a newer version of make than on other platforms
20302   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20303     MAKE_VERSION_EXPR="-e 4\."
20304     MAKE_REQUIRED_VERSION="4.0"
20305    else
20306     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
20307     MAKE_REQUIRED_VERSION="3.81"
20308   fi
20309 
20310   if test "x$MAKE_CANDIDATE" != x; then
20311     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
20312 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
20313     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
20314     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
20315     if test "x$IS_GNU_MAKE" = x; then
20316       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
20317 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
20318     else
20319       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
20320       if test "x$IS_MODERN_MAKE" = x; then
20321         { $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
20322 $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;}
20323       else
20324         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
20325           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20326             MAKE_EXPECTED_ENV='cygwin'
20327           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20328             MAKE_EXPECTED_ENV='msys'
20329           else
20330             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
20331           fi
20332           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
20333           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
20334         else
20335           # Not relevant for non-Windows
20336           IS_MAKE_CORRECT_ENV=true
20337         fi
20338         if test "x$IS_MAKE_CORRECT_ENV" = x; then
20339           { $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
20340 $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;}
20341         else
20342           FOUND_MAKE=$MAKE_CANDIDATE
20343 
20344   # Only process if variable expands to non-empty
20345 
20346   if test "x$FOUND_MAKE" != x; then
20347     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20348 
20349   # First separate the path from the arguments. This will split at the first
20350   # space.
20351   complete="$FOUND_MAKE"
20352   path="${complete%% *}"
20353   tmp="$complete EOL"
20354   arguments="${tmp#* }"
20355 
20356   # Input might be given as Windows format, start by converting to
20357   # unix format.
20358   new_path=`$CYGPATH -u "$path"`
20359 
20360   # Now try to locate executable using which
20361   new_path=`$WHICH "$new_path" 2> /dev/null`
20362   # bat and cmd files are not always considered executable in cygwin causing which
20363   # to not find them
20364   if test "x$new_path" = x \
20365       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
20366       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
20367     new_path=`$CYGPATH -u "$path"`
20368   fi
20369   if test "x$new_path" = x; then
20370     # Oops. Which didn't find the executable.
20371     # The splitting of arguments from the executable at a space might have been incorrect,
20372     # since paths with space are more likely in Windows. Give it another try with the whole
20373     # argument.
20374     path="$complete"
20375     arguments="EOL"
20376     new_path=`$CYGPATH -u "$path"`
20377     new_path=`$WHICH "$new_path" 2> /dev/null`
20378     # bat and cmd files are not always considered executable in cygwin causing which
20379     # to not find them
20380     if test "x$new_path" = x \
20381         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
20382         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
20383       new_path=`$CYGPATH -u "$path"`
20384     fi
20385     if test "x$new_path" = x; then
20386       # It's still not found. Now this is an unrecoverable error.
20387       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
20388 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
20389       has_space=`$ECHO "$complete" | $GREP " "`
20390       if test "x$has_space" != x; then
20391         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
20392 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
20393       fi
20394       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
20395     fi
20396   fi
20397 
20398   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
20399   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
20400   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
20401   # "foo.exe" is OK but "foo" is an error.
20402   #
20403   # This test is therefore slightly more accurate than "test -f" to check for file presence.
20404   # It is also a way to make sure we got the proper file name for the real test later on.
20405   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
20406   if test "x$test_shortpath" = x; then
20407     # Short path failed, file does not exist as specified.
20408     # Try adding .exe or .cmd
20409     if test -f "${new_path}.exe"; then
20410       input_to_shortpath="${new_path}.exe"
20411     elif test -f "${new_path}.cmd"; then
20412       input_to_shortpath="${new_path}.cmd"
20413     else
20414       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
20415 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
20416       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
20417 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
20418       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
20419     fi
20420   else
20421     input_to_shortpath="$new_path"
20422   fi
20423 
20424   # Call helper function which possibly converts this using DOS-style short mode.
20425   # If so, the updated path is stored in $new_path.
20426   new_path="$input_to_shortpath"
20427 
20428   input_path="$input_to_shortpath"
20429   # Check if we need to convert this using DOS-style short mode. If the path
20430   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20431   # take no chances and rewrite it.
20432   # Note: m4 eats our [], so we need to use [ and ] instead.
20433   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20434   if test "x$has_forbidden_chars" != x; then
20435     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20436     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20437     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20438     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20439       # Going to short mode and back again did indeed matter. Since short mode is
20440       # case insensitive, let's make it lowercase to improve readability.
20441       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20442       # Now convert it back to Unix-style (cygpath)
20443       input_path=`$CYGPATH -u "$shortmode_path"`
20444       new_path="$input_path"
20445     fi
20446   fi
20447 
20448   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20449   if test "x$test_cygdrive_prefix" = x; then
20450     # As a simple fix, exclude /usr/bin since it's not a real path.
20451     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
20452       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20453       # a path prefixed by /cygdrive for fixpath to work.
20454       new_path="$CYGWIN_ROOT_PATH$input_path"
20455     fi
20456   fi
20457 
20458   # remove trailing .exe if any
20459   new_path="${new_path/%.exe/}"
20460 
20461     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20462 
20463   # First separate the path from the arguments. This will split at the first
20464   # space.
20465   complete="$FOUND_MAKE"
20466   path="${complete%% *}"
20467   tmp="$complete EOL"
20468   arguments="${tmp#* }"
20469 
20470   # Input might be given as Windows format, start by converting to
20471   # unix format.
20472   new_path="$path"
20473 
20474   windows_path="$new_path"
20475   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20476     unix_path=`$CYGPATH -u "$windows_path"`
20477     new_path="$unix_path"
20478   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20479     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20480     new_path="$unix_path"
20481   fi
20482 
20483 
20484   # Now try to locate executable using which
20485   new_path=`$WHICH "$new_path" 2> /dev/null`
20486 
20487   if test "x$new_path" = x; then
20488     # Oops. Which didn't find the executable.
20489     # The splitting of arguments from the executable at a space might have been incorrect,
20490     # since paths with space are more likely in Windows. Give it another try with the whole
20491     # argument.
20492     path="$complete"
20493     arguments="EOL"
20494     new_path="$path"
20495 
20496   windows_path="$new_path"
20497   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20498     unix_path=`$CYGPATH -u "$windows_path"`
20499     new_path="$unix_path"
20500   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20501     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20502     new_path="$unix_path"
20503   fi
20504 
20505 
20506     new_path=`$WHICH "$new_path" 2> /dev/null`
20507     # bat and cmd files are not always considered executable in MSYS causing which
20508     # to not find them
20509     if test "x$new_path" = x \
20510         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
20511         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
20512       new_path="$path"
20513 
20514   windows_path="$new_path"
20515   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20516     unix_path=`$CYGPATH -u "$windows_path"`
20517     new_path="$unix_path"
20518   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20519     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20520     new_path="$unix_path"
20521   fi
20522 
20523     fi
20524 
20525     if test "x$new_path" = x; then
20526       # It's still not found. Now this is an unrecoverable error.
20527       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
20528 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
20529       has_space=`$ECHO "$complete" | $GREP " "`
20530       if test "x$has_space" != x; then
20531         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
20532 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
20533       fi
20534       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
20535     fi
20536   fi
20537 
20538   # Now new_path has a complete unix path to the binary
20539   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
20540     # Keep paths in /bin as-is, but remove trailing .exe if any
20541     new_path="${new_path/%.exe/}"
20542     # Do not save /bin paths to all_fixpath_prefixes!
20543   else
20544     # Not in mixed or Windows style, start by that.
20545     new_path=`cmd //c echo $new_path`
20546 
20547   input_path="$new_path"
20548   # Check if we need to convert this using DOS-style short mode. If the path
20549   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20550   # take no chances and rewrite it.
20551   # Note: m4 eats our [], so we need to use [ and ] instead.
20552   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20553   if test "x$has_forbidden_chars" != x; then
20554     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20555     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20556   fi
20557 
20558     # Output is in $new_path
20559 
20560   windows_path="$new_path"
20561   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20562     unix_path=`$CYGPATH -u "$windows_path"`
20563     new_path="$unix_path"
20564   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20565     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20566     new_path="$unix_path"
20567   fi
20568 
20569     # remove trailing .exe if any
20570     new_path="${new_path/%.exe/}"
20571 
20572     # Save the first 10 bytes of this path to the storage, so fixpath can work.
20573     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20574   fi
20575 
20576     else
20577       # We're on a unix platform. Hooray! :)
20578       # First separate the path from the arguments. This will split at the first
20579       # space.
20580       complete="$FOUND_MAKE"
20581       path="${complete%% *}"
20582       tmp="$complete EOL"
20583       arguments="${tmp#* }"
20584 
20585       # Cannot rely on the command "which" here since it doesn't always work.
20586       is_absolute_path=`$ECHO "$path" | $GREP ^/`
20587       if test -z "$is_absolute_path"; then
20588         # Path to executable is not absolute. Find it.
20589         IFS_save="$IFS"
20590         IFS=:
20591         for p in $PATH; do
20592           if test -f "$p/$path" && test -x "$p/$path"; then
20593             new_path="$p/$path"
20594             break
20595           fi
20596         done
20597         IFS="$IFS_save"
20598       else
20599         # This is an absolute path, we can use it without further modifications.
20600         new_path="$path"
20601       fi
20602 
20603       if test "x$new_path" = x; then
20604         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
20605 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
20606         has_space=`$ECHO "$complete" | $GREP " "`
20607         if test "x$has_space" != x; then
20608           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
20609 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
20610         fi
20611         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
20612       fi
20613     fi
20614 
20615     # Now join together the path and the arguments once again
20616     if test "x$arguments" != xEOL; then
20617       new_complete="$new_path ${arguments% *}"
20618     else
20619       new_complete="$new_path"
20620     fi
20621 
20622     if test "x$complete" != "x$new_complete"; then
20623       FOUND_MAKE="$new_complete"
20624       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
20625 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
20626     fi
20627   fi
20628 
20629         fi
20630       fi
20631     fi
20632   fi
20633 
20634         fi
20635         PATH=$OLD_PATH
20636       fi
20637     fi
20638 
20639     if test "x$FOUND_MAKE" = x; then
20640       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
20641     fi
20642 
20643     else
20644       # If it succeeded, then it was overridden by the user. We will use it
20645       # for the tool.
20646 
20647       # First remove it from the list of overridden variables, so we can test
20648       # for unknown variables in the end.
20649       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
20650 
20651       # Check if we try to supply an empty value
20652       if test "x$MAKE" = x; then
20653         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool MAKE= (no value)" >&5
20654 $as_echo "$as_me: Setting user supplied tool MAKE= (no value)" >&6;}
20655         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MAKE" >&5
20656 $as_echo_n "checking for MAKE... " >&6; }
20657         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
20658 $as_echo "disabled" >&6; }
20659       else
20660         # Check if the provided tool contains a complete path.
20661         tool_specified="$MAKE"
20662         tool_basename="${tool_specified##*/}"
20663         if test "x$tool_basename" = "x$tool_specified"; then
20664           # A command without a complete path is provided, search $PATH.
20665           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MAKE=$tool_basename" >&5
20666 $as_echo "$as_me: Will search for user supplied tool MAKE=$tool_basename" >&6;}
20667           # Extract the first word of "$tool_basename", so it can be a program name with args.
20668 set dummy $tool_basename; 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_MAKE+:} false; then :
20672   $as_echo_n "(cached) " >&6
20673 else
20674   case $MAKE in
20675   [\\/]* | ?:[\\/]*)
20676   ac_cv_path_MAKE="$MAKE" # 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_MAKE="$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 MAKE=$ac_cv_path_MAKE
20698 if test -n "$MAKE"; then
20699   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MAKE" >&5
20700 $as_echo "$MAKE" >&6; }
20701 else
20702   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20703 $as_echo "no" >&6; }
20704 fi
20705 
20706 
20707           if test "x$MAKE" = x; then
20708             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
20709           fi
20710         else
20711           # Otherwise we believe it is a complete path. Use it as it is.
20712           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MAKE=$tool_specified" >&5
20713 $as_echo "$as_me: Will use user supplied tool MAKE=$tool_specified" >&6;}
20714           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MAKE" >&5
20715 $as_echo_n "checking for MAKE... " >&6; }
20716           if test ! -x "$tool_specified"; then
20717             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
20718 $as_echo "not found" >&6; }
20719             as_fn_error $? "User supplied tool MAKE=$tool_specified does not exist or is not executable" "$LINENO" 5
20720           fi
20721           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
20722 $as_echo "$tool_specified" >&6; }
20723         fi
20724       fi
20725     fi
20726 
20727     # If MAKE was set by user, verify the version
20728 
20729   MAKE_CANDIDATE=""$MAKE""
20730   DESCRIPTION="user supplied MAKE=$MAKE"
20731 
20732   # On Cygwin, we require a newer version of make than on other platforms
20733   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20734     MAKE_VERSION_EXPR="-e 4\."
20735     MAKE_REQUIRED_VERSION="4.0"
20736    else
20737     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
20738     MAKE_REQUIRED_VERSION="3.81"
20739   fi
20740 
20741   if test "x$MAKE_CANDIDATE" != x; then
20742     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
20743 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
20744     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
20745     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
20746     if test "x$IS_GNU_MAKE" = x; then
20747       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
20748 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
20749     else
20750       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
20751       if test "x$IS_MODERN_MAKE" = x; then
20752         { $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
20753 $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;}
20754       else
20755         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
20756           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20757             MAKE_EXPECTED_ENV='cygwin'
20758           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20759             MAKE_EXPECTED_ENV='msys'
20760           else
20761             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
20762           fi
20763           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
20764           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
20765         else
20766           # Not relevant for non-Windows
20767           IS_MAKE_CORRECT_ENV=true
20768         fi
20769         if test "x$IS_MAKE_CORRECT_ENV" = x; then
20770           { $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
20771 $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;}
20772         else
20773           FOUND_MAKE=$MAKE_CANDIDATE
20774 
20775   # Only process if variable expands to non-empty
20776 
20777   if test "x$FOUND_MAKE" != x; then
20778     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20779 
20780   # First separate the path from the arguments. This will split at the first
20781   # space.
20782   complete="$FOUND_MAKE"
20783   path="${complete%% *}"
20784   tmp="$complete EOL"
20785   arguments="${tmp#* }"
20786 
20787   # Input might be given as Windows format, start by converting to
20788   # unix format.
20789   new_path=`$CYGPATH -u "$path"`
20790 
20791   # Now try to locate executable using which
20792   new_path=`$WHICH "$new_path" 2> /dev/null`
20793   # bat and cmd files are not always considered executable in cygwin causing which
20794   # to not find them
20795   if test "x$new_path" = x \
20796       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
20797       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
20798     new_path=`$CYGPATH -u "$path"`
20799   fi
20800   if test "x$new_path" = x; then
20801     # Oops. Which didn't find the executable.
20802     # The splitting of arguments from the executable at a space might have been incorrect,
20803     # since paths with space are more likely in Windows. Give it another try with the whole
20804     # argument.
20805     path="$complete"
20806     arguments="EOL"
20807     new_path=`$CYGPATH -u "$path"`
20808     new_path=`$WHICH "$new_path" 2> /dev/null`
20809     # bat and cmd files are not always considered executable in cygwin causing which
20810     # to not find them
20811     if test "x$new_path" = x \
20812         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
20813         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
20814       new_path=`$CYGPATH -u "$path"`
20815     fi
20816     if test "x$new_path" = x; then
20817       # It's still not found. Now this is an unrecoverable error.
20818       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
20819 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
20820       has_space=`$ECHO "$complete" | $GREP " "`
20821       if test "x$has_space" != x; then
20822         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
20823 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
20824       fi
20825       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
20826     fi
20827   fi
20828 
20829   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
20830   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
20831   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
20832   # "foo.exe" is OK but "foo" is an error.
20833   #
20834   # This test is therefore slightly more accurate than "test -f" to check for file presence.
20835   # It is also a way to make sure we got the proper file name for the real test later on.
20836   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
20837   if test "x$test_shortpath" = x; then
20838     # Short path failed, file does not exist as specified.
20839     # Try adding .exe or .cmd
20840     if test -f "${new_path}.exe"; then
20841       input_to_shortpath="${new_path}.exe"
20842     elif test -f "${new_path}.cmd"; then
20843       input_to_shortpath="${new_path}.cmd"
20844     else
20845       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
20846 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
20847       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
20848 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
20849       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
20850     fi
20851   else
20852     input_to_shortpath="$new_path"
20853   fi
20854 
20855   # Call helper function which possibly converts this using DOS-style short mode.
20856   # If so, the updated path is stored in $new_path.
20857   new_path="$input_to_shortpath"
20858 
20859   input_path="$input_to_shortpath"
20860   # Check if we need to convert this using DOS-style short mode. If the path
20861   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20862   # take no chances and rewrite it.
20863   # Note: m4 eats our [], so we need to use [ and ] instead.
20864   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20865   if test "x$has_forbidden_chars" != x; then
20866     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20867     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20868     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20869     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20870       # Going to short mode and back again did indeed matter. Since short mode is
20871       # case insensitive, let's make it lowercase to improve readability.
20872       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20873       # Now convert it back to Unix-style (cygpath)
20874       input_path=`$CYGPATH -u "$shortmode_path"`
20875       new_path="$input_path"
20876     fi
20877   fi
20878 
20879   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20880   if test "x$test_cygdrive_prefix" = x; then
20881     # As a simple fix, exclude /usr/bin since it's not a real path.
20882     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
20883       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20884       # a path prefixed by /cygdrive for fixpath to work.
20885       new_path="$CYGWIN_ROOT_PATH$input_path"
20886     fi
20887   fi
20888 
20889   # remove trailing .exe if any
20890   new_path="${new_path/%.exe/}"
20891 
20892     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20893 
20894   # First separate the path from the arguments. This will split at the first
20895   # space.
20896   complete="$FOUND_MAKE"
20897   path="${complete%% *}"
20898   tmp="$complete EOL"
20899   arguments="${tmp#* }"
20900 
20901   # Input might be given as Windows format, start by converting to
20902   # unix format.
20903   new_path="$path"
20904 
20905   windows_path="$new_path"
20906   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20907     unix_path=`$CYGPATH -u "$windows_path"`
20908     new_path="$unix_path"
20909   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20910     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20911     new_path="$unix_path"
20912   fi
20913 
20914 
20915   # Now try to locate executable using which
20916   new_path=`$WHICH "$new_path" 2> /dev/null`
20917 
20918   if test "x$new_path" = x; then
20919     # Oops. Which didn't find the executable.
20920     # The splitting of arguments from the executable at a space might have been incorrect,
20921     # since paths with space are more likely in Windows. Give it another try with the whole
20922     # argument.
20923     path="$complete"
20924     arguments="EOL"
20925     new_path="$path"
20926 
20927   windows_path="$new_path"
20928   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20929     unix_path=`$CYGPATH -u "$windows_path"`
20930     new_path="$unix_path"
20931   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20932     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20933     new_path="$unix_path"
20934   fi
20935 
20936 
20937     new_path=`$WHICH "$new_path" 2> /dev/null`
20938     # bat and cmd files are not always considered executable in MSYS causing which
20939     # to not find them
20940     if test "x$new_path" = x \
20941         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
20942         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
20943       new_path="$path"
20944 
20945   windows_path="$new_path"
20946   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20947     unix_path=`$CYGPATH -u "$windows_path"`
20948     new_path="$unix_path"
20949   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20950     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20951     new_path="$unix_path"
20952   fi
20953 
20954     fi
20955 
20956     if test "x$new_path" = x; then
20957       # It's still not found. Now this is an unrecoverable error.
20958       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
20959 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
20960       has_space=`$ECHO "$complete" | $GREP " "`
20961       if test "x$has_space" != x; then
20962         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
20963 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
20964       fi
20965       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
20966     fi
20967   fi
20968 
20969   # Now new_path has a complete unix path to the binary
20970   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
20971     # Keep paths in /bin as-is, but remove trailing .exe if any
20972     new_path="${new_path/%.exe/}"
20973     # Do not save /bin paths to all_fixpath_prefixes!
20974   else
20975     # Not in mixed or Windows style, start by that.
20976     new_path=`cmd //c echo $new_path`
20977 
20978   input_path="$new_path"
20979   # Check if we need to convert this using DOS-style short mode. If the path
20980   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20981   # take no chances and rewrite it.
20982   # Note: m4 eats our [], so we need to use [ and ] instead.
20983   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20984   if test "x$has_forbidden_chars" != x; then
20985     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20986     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20987   fi
20988 
20989     # Output is in $new_path
20990 
20991   windows_path="$new_path"
20992   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20993     unix_path=`$CYGPATH -u "$windows_path"`
20994     new_path="$unix_path"
20995   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20996     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20997     new_path="$unix_path"
20998   fi
20999 
21000     # remove trailing .exe if any
21001     new_path="${new_path/%.exe/}"
21002 
21003     # Save the first 10 bytes of this path to the storage, so fixpath can work.
21004     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21005   fi
21006 
21007     else
21008       # We're on a unix platform. Hooray! :)
21009       # First separate the path from the arguments. This will split at the first
21010       # space.
21011       complete="$FOUND_MAKE"
21012       path="${complete%% *}"
21013       tmp="$complete EOL"
21014       arguments="${tmp#* }"
21015 
21016       # Cannot rely on the command "which" here since it doesn't always work.
21017       is_absolute_path=`$ECHO "$path" | $GREP ^/`
21018       if test -z "$is_absolute_path"; then
21019         # Path to executable is not absolute. Find it.
21020         IFS_save="$IFS"
21021         IFS=:
21022         for p in $PATH; do
21023           if test -f "$p/$path" && test -x "$p/$path"; then
21024             new_path="$p/$path"
21025             break
21026           fi
21027         done
21028         IFS="$IFS_save"
21029       else
21030         # This is an absolute path, we can use it without further modifications.
21031         new_path="$path"
21032       fi
21033 
21034       if test "x$new_path" = x; then
21035         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
21036 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
21037         has_space=`$ECHO "$complete" | $GREP " "`
21038         if test "x$has_space" != x; then
21039           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
21040 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
21041         fi
21042         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
21043       fi
21044     fi
21045 
21046     # Now join together the path and the arguments once again
21047     if test "x$arguments" != xEOL; then
21048       new_complete="$new_path ${arguments% *}"
21049     else
21050       new_complete="$new_path"
21051     fi
21052 
21053     if test "x$complete" != "x$new_complete"; then
21054       FOUND_MAKE="$new_complete"
21055       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
21056 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
21057     fi
21058   fi
21059 
21060         fi
21061       fi
21062     fi
21063   fi
21064 
21065     if test "x$FOUND_MAKE" = x; then
21066       as_fn_error $? "The specified make (by MAKE=$MAKE) is not GNU make $MAKE_REQUIRED_VERSION or newer." "$LINENO" 5
21067     fi
21068 
21069   fi
21070 
21071 
21072   MAKE=$FOUND_MAKE
21073 
21074   { $as_echo "$as_me:${as_lineno-$LINENO}: Using GNU make at $FOUND_MAKE (version: $MAKE_VERSION_STRING)" >&5
21075 $as_echo "$as_me: Using GNU make at $FOUND_MAKE (version: $MAKE_VERSION_STRING)" >&6;}
21076 
21077 
21078   # Check if make supports the output sync option and if so, setup using it.
21079   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if make --output-sync is supported" >&5
21080 $as_echo_n "checking if make --output-sync is supported... " >&6; }
21081   if $MAKE --version -O > /dev/null 2>&1; then
21082     OUTPUT_SYNC_SUPPORTED=true
21083     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
21084 $as_echo "yes" >&6; }
21085     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for output-sync value" >&5
21086 $as_echo_n "checking for output-sync value... " >&6; }
21087 
21088 # Check whether --with-output-sync was given.
21089 if test "${with_output_sync+set}" = set; then :
21090   withval=$with_output_sync; OUTPUT_SYNC=$with_output_sync
21091 fi
21092 
21093     if test "x$OUTPUT_SYNC" = "x"; then
21094       OUTPUT_SYNC=none
21095     fi
21096     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OUTPUT_SYNC" >&5
21097 $as_echo "$OUTPUT_SYNC" >&6; }
21098     if ! $MAKE --version -O$OUTPUT_SYNC > /dev/null 2>&1; then
21099       as_fn_error $? "Make did not the support the value $OUTPUT_SYNC as output sync type." "$LINENO" 5
21100     fi
21101   else
21102     OUTPUT_SYNC_SUPPORTED=false
21103     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21104 $as_echo "no" >&6; }
21105   fi
21106 
21107 
21108 
21109 
21110 
21111 
21112   # Test if find supports -delete
21113   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if find supports -delete" >&5
21114 $as_echo_n "checking if find supports -delete... " >&6; }
21115   FIND_DELETE="-delete"
21116 
21117   DELETEDIR=`$MKTEMP -d tmp.XXXXXXXXXX` || (echo Could not create temporary directory!; exit $?)
21118 
21119   echo Hejsan > $DELETEDIR/TestIfFindSupportsDelete
21120 
21121   TEST_DELETE=`$FIND "$DELETEDIR" -name TestIfFindSupportsDelete $FIND_DELETE 2>&1`
21122   if test -f $DELETEDIR/TestIfFindSupportsDelete; then
21123     # No, it does not.
21124     $RM $DELETEDIR/TestIfFindSupportsDelete
21125     if test "x$OPENJDK_TARGET_OS" = "xaix"; then
21126       # AIX 'find' is buggy if called with '-exec {} \+' and an empty file list
21127       FIND_DELETE="-print | $XARGS $RM"
21128     else
21129       FIND_DELETE="-exec $RM \{\} \+"
21130     fi
21131     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21132 $as_echo "no" >&6; }
21133   else
21134     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
21135 $as_echo "yes" >&6; }
21136   fi
21137   $RMDIR $DELETEDIR
21138 
21139 
21140 
21141   # Test which kind of tar was found
21142   if test "x$($TAR --version | $GREP "GNU tar")" != "x"; then
21143     TAR_TYPE="gnu"
21144   elif test "x$($TAR -v | $GREP "bsdtar")" != "x"; then
21145     TAR_TYPE="bsd"
21146   elif test "x$OPENJDK_BUILD_OS" = "xsolaris"; then
21147     TAR_TYPE="solaris"
21148   fi
21149   { $as_echo "$as_me:${as_lineno-$LINENO}: checking what type of tar was found" >&5
21150 $as_echo_n "checking what type of tar was found... " >&6; }
21151   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR_TYPE" >&5
21152 $as_echo "$TAR_TYPE" >&6; }
21153 
21154   TAR_CREATE_FILE_PARAM=""
21155 
21156   if test "x$TAR_TYPE" = "xgnu"; then
21157     TAR_INCLUDE_PARAM="T"
21158     TAR_SUPPORTS_TRANSFORM="true"
21159     if test "x$OPENJDK_TARGET_OS" = "xsolaris"; then
21160       # When using gnu tar for Solaris targets, need to use compatibility mode
21161       TAR_CREATE_EXTRA_PARAM="--format=ustar"
21162     fi
21163   else
21164     TAR_INCLUDE_PARAM="I"
21165     TAR_SUPPORTS_TRANSFORM="false"
21166   fi
21167 
21168 
21169 
21170 
21171 
21172 
21173   # These tools might not be installed by default,
21174   # need hint on how to install them.
21175 
21176 
21177 
21178   # Publish this variable in the help.
21179 
21180 
21181   if [ -z "${UNZIP+x}" ]; then
21182     # The variable is not set by user, try to locate tool using the code snippet
21183     for ac_prog in unzip
21184 do
21185   # Extract the first word of "$ac_prog", so it can be a program name with args.
21186 set dummy $ac_prog; ac_word=$2
21187 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21188 $as_echo_n "checking for $ac_word... " >&6; }
21189 if ${ac_cv_path_UNZIP+:} false; then :
21190   $as_echo_n "(cached) " >&6
21191 else
21192   case $UNZIP in
21193   [\\/]* | ?:[\\/]*)
21194   ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
21195   ;;
21196   *)
21197   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21198 for as_dir in $PATH
21199 do
21200   IFS=$as_save_IFS
21201   test -z "$as_dir" && as_dir=.
21202     for ac_exec_ext in '' $ac_executable_extensions; do
21203   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21204     ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
21205     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21206     break 2
21207   fi
21208 done
21209   done
21210 IFS=$as_save_IFS
21211 
21212   ;;
21213 esac
21214 fi
21215 UNZIP=$ac_cv_path_UNZIP
21216 if test -n "$UNZIP"; then
21217   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
21218 $as_echo "$UNZIP" >&6; }
21219 else
21220   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21221 $as_echo "no" >&6; }
21222 fi
21223 
21224 
21225   test -n "$UNZIP" && break
21226 done
21227 
21228   else
21229     # The variable is set, but is it from the command line or the environment?
21230 
21231     # Try to remove the string !UNZIP! from our list.
21232     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNZIP!/}
21233     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
21234       # If it failed, the variable was not from the command line. Ignore it,
21235       # but warn the user (except for BASH, which is always set by the calling BASH).
21236       if test "xUNZIP" != xBASH; then
21237         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNZIP from the environment. Use command line variables instead." >&5
21238 $as_echo "$as_me: WARNING: Ignoring value of UNZIP from the environment. Use command line variables instead." >&2;}
21239       fi
21240       # Try to locate tool using the code snippet
21241       for ac_prog in unzip
21242 do
21243   # Extract the first word of "$ac_prog", so it can be a program name with args.
21244 set dummy $ac_prog; ac_word=$2
21245 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21246 $as_echo_n "checking for $ac_word... " >&6; }
21247 if ${ac_cv_path_UNZIP+:} false; then :
21248   $as_echo_n "(cached) " >&6
21249 else
21250   case $UNZIP in
21251   [\\/]* | ?:[\\/]*)
21252   ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
21253   ;;
21254   *)
21255   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21256 for as_dir in $PATH
21257 do
21258   IFS=$as_save_IFS
21259   test -z "$as_dir" && as_dir=.
21260     for ac_exec_ext in '' $ac_executable_extensions; do
21261   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21262     ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
21263     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21264     break 2
21265   fi
21266 done
21267   done
21268 IFS=$as_save_IFS
21269 
21270   ;;
21271 esac
21272 fi
21273 UNZIP=$ac_cv_path_UNZIP
21274 if test -n "$UNZIP"; then
21275   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
21276 $as_echo "$UNZIP" >&6; }
21277 else
21278   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21279 $as_echo "no" >&6; }
21280 fi
21281 
21282 
21283   test -n "$UNZIP" && break
21284 done
21285 
21286     else
21287       # If it succeeded, then it was overridden by the user. We will use it
21288       # for the tool.
21289 
21290       # First remove it from the list of overridden variables, so we can test
21291       # for unknown variables in the end.
21292       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
21293 
21294       # Check if we try to supply an empty value
21295       if test "x$UNZIP" = x; then
21296         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool UNZIP= (no value)" >&5
21297 $as_echo "$as_me: Setting user supplied tool UNZIP= (no value)" >&6;}
21298         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNZIP" >&5
21299 $as_echo_n "checking for UNZIP... " >&6; }
21300         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
21301 $as_echo "disabled" >&6; }
21302       else
21303         # Check if the provided tool contains a complete path.
21304         tool_specified="$UNZIP"
21305         tool_basename="${tool_specified##*/}"
21306         if test "x$tool_basename" = "x$tool_specified"; then
21307           # A command without a complete path is provided, search $PATH.
21308           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNZIP=$tool_basename" >&5
21309 $as_echo "$as_me: Will search for user supplied tool UNZIP=$tool_basename" >&6;}
21310           # Extract the first word of "$tool_basename", so it can be a program name with args.
21311 set dummy $tool_basename; ac_word=$2
21312 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21313 $as_echo_n "checking for $ac_word... " >&6; }
21314 if ${ac_cv_path_UNZIP+:} false; then :
21315   $as_echo_n "(cached) " >&6
21316 else
21317   case $UNZIP in
21318   [\\/]* | ?:[\\/]*)
21319   ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
21320   ;;
21321   *)
21322   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21323 for as_dir in $PATH
21324 do
21325   IFS=$as_save_IFS
21326   test -z "$as_dir" && as_dir=.
21327     for ac_exec_ext in '' $ac_executable_extensions; do
21328   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21329     ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
21330     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21331     break 2
21332   fi
21333 done
21334   done
21335 IFS=$as_save_IFS
21336 
21337   ;;
21338 esac
21339 fi
21340 UNZIP=$ac_cv_path_UNZIP
21341 if test -n "$UNZIP"; then
21342   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
21343 $as_echo "$UNZIP" >&6; }
21344 else
21345   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21346 $as_echo "no" >&6; }
21347 fi
21348 
21349 
21350           if test "x$UNZIP" = x; then
21351             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
21352           fi
21353         else
21354           # Otherwise we believe it is a complete path. Use it as it is.
21355           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNZIP=$tool_specified" >&5
21356 $as_echo "$as_me: Will use user supplied tool UNZIP=$tool_specified" >&6;}
21357           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNZIP" >&5
21358 $as_echo_n "checking for UNZIP... " >&6; }
21359           if test ! -x "$tool_specified"; then
21360             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
21361 $as_echo "not found" >&6; }
21362             as_fn_error $? "User supplied tool UNZIP=$tool_specified does not exist or is not executable" "$LINENO" 5
21363           fi
21364           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
21365 $as_echo "$tool_specified" >&6; }
21366         fi
21367       fi
21368     fi
21369 
21370   fi
21371 
21372 
21373 
21374   if test "x$UNZIP" = x; then
21375     as_fn_error $? "Could not find required tool for UNZIP" "$LINENO" 5
21376   fi
21377 
21378 
21379 
21380 
21381 
21382   # Publish this variable in the help.
21383 
21384 
21385   if [ -z "${ZIP+x}" ]; then
21386     # The variable is not set by user, try to locate tool using the code snippet
21387     for ac_prog in zip
21388 do
21389   # Extract the first word of "$ac_prog", so it can be a program name with args.
21390 set dummy $ac_prog; ac_word=$2
21391 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21392 $as_echo_n "checking for $ac_word... " >&6; }
21393 if ${ac_cv_path_ZIP+:} false; then :
21394   $as_echo_n "(cached) " >&6
21395 else
21396   case $ZIP in
21397   [\\/]* | ?:[\\/]*)
21398   ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
21399   ;;
21400   *)
21401   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21402 for as_dir in $PATH
21403 do
21404   IFS=$as_save_IFS
21405   test -z "$as_dir" && as_dir=.
21406     for ac_exec_ext in '' $ac_executable_extensions; do
21407   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21408     ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
21409     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21410     break 2
21411   fi
21412 done
21413   done
21414 IFS=$as_save_IFS
21415 
21416   ;;
21417 esac
21418 fi
21419 ZIP=$ac_cv_path_ZIP
21420 if test -n "$ZIP"; then
21421   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
21422 $as_echo "$ZIP" >&6; }
21423 else
21424   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21425 $as_echo "no" >&6; }
21426 fi
21427 
21428 
21429   test -n "$ZIP" && break
21430 done
21431 
21432   else
21433     # The variable is set, but is it from the command line or the environment?
21434 
21435     # Try to remove the string !ZIP! from our list.
21436     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!ZIP!/}
21437     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
21438       # If it failed, the variable was not from the command line. Ignore it,
21439       # but warn the user (except for BASH, which is always set by the calling BASH).
21440       if test "xZIP" != xBASH; then
21441         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ZIP from the environment. Use command line variables instead." >&5
21442 $as_echo "$as_me: WARNING: Ignoring value of ZIP from the environment. Use command line variables instead." >&2;}
21443       fi
21444       # Try to locate tool using the code snippet
21445       for ac_prog in zip
21446 do
21447   # Extract the first word of "$ac_prog", so it can be a program name with args.
21448 set dummy $ac_prog; ac_word=$2
21449 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21450 $as_echo_n "checking for $ac_word... " >&6; }
21451 if ${ac_cv_path_ZIP+:} false; then :
21452   $as_echo_n "(cached) " >&6
21453 else
21454   case $ZIP in
21455   [\\/]* | ?:[\\/]*)
21456   ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
21457   ;;
21458   *)
21459   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21460 for as_dir in $PATH
21461 do
21462   IFS=$as_save_IFS
21463   test -z "$as_dir" && as_dir=.
21464     for ac_exec_ext in '' $ac_executable_extensions; do
21465   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21466     ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
21467     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21468     break 2
21469   fi
21470 done
21471   done
21472 IFS=$as_save_IFS
21473 
21474   ;;
21475 esac
21476 fi
21477 ZIP=$ac_cv_path_ZIP
21478 if test -n "$ZIP"; then
21479   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
21480 $as_echo "$ZIP" >&6; }
21481 else
21482   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21483 $as_echo "no" >&6; }
21484 fi
21485 
21486 
21487   test -n "$ZIP" && break
21488 done
21489 
21490     else
21491       # If it succeeded, then it was overridden by the user. We will use it
21492       # for the tool.
21493 
21494       # First remove it from the list of overridden variables, so we can test
21495       # for unknown variables in the end.
21496       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
21497 
21498       # Check if we try to supply an empty value
21499       if test "x$ZIP" = x; then
21500         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool ZIP= (no value)" >&5
21501 $as_echo "$as_me: Setting user supplied tool ZIP= (no value)" >&6;}
21502         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ZIP" >&5
21503 $as_echo_n "checking for ZIP... " >&6; }
21504         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
21505 $as_echo "disabled" >&6; }
21506       else
21507         # Check if the provided tool contains a complete path.
21508         tool_specified="$ZIP"
21509         tool_basename="${tool_specified##*/}"
21510         if test "x$tool_basename" = "x$tool_specified"; then
21511           # A command without a complete path is provided, search $PATH.
21512           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ZIP=$tool_basename" >&5
21513 $as_echo "$as_me: Will search for user supplied tool ZIP=$tool_basename" >&6;}
21514           # Extract the first word of "$tool_basename", so it can be a program name with args.
21515 set dummy $tool_basename; ac_word=$2
21516 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21517 $as_echo_n "checking for $ac_word... " >&6; }
21518 if ${ac_cv_path_ZIP+:} false; then :
21519   $as_echo_n "(cached) " >&6
21520 else
21521   case $ZIP in
21522   [\\/]* | ?:[\\/]*)
21523   ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
21524   ;;
21525   *)
21526   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21527 for as_dir in $PATH
21528 do
21529   IFS=$as_save_IFS
21530   test -z "$as_dir" && as_dir=.
21531     for ac_exec_ext in '' $ac_executable_extensions; do
21532   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21533     ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
21534     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21535     break 2
21536   fi
21537 done
21538   done
21539 IFS=$as_save_IFS
21540 
21541   ;;
21542 esac
21543 fi
21544 ZIP=$ac_cv_path_ZIP
21545 if test -n "$ZIP"; then
21546   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
21547 $as_echo "$ZIP" >&6; }
21548 else
21549   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21550 $as_echo "no" >&6; }
21551 fi
21552 
21553 
21554           if test "x$ZIP" = x; then
21555             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
21556           fi
21557         else
21558           # Otherwise we believe it is a complete path. Use it as it is.
21559           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ZIP=$tool_specified" >&5
21560 $as_echo "$as_me: Will use user supplied tool ZIP=$tool_specified" >&6;}
21561           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ZIP" >&5
21562 $as_echo_n "checking for ZIP... " >&6; }
21563           if test ! -x "$tool_specified"; then
21564             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
21565 $as_echo "not found" >&6; }
21566             as_fn_error $? "User supplied tool ZIP=$tool_specified does not exist or is not executable" "$LINENO" 5
21567           fi
21568           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
21569 $as_echo "$tool_specified" >&6; }
21570         fi
21571       fi
21572     fi
21573 
21574   fi
21575 
21576 
21577 
21578   if test "x$ZIP" = x; then
21579     as_fn_error $? "Could not find required tool for ZIP" "$LINENO" 5
21580   fi
21581 
21582 
21583 
21584   # Non-required basic tools
21585 
21586 
21587 
21588   # Publish this variable in the help.
21589 
21590 
21591   if [ -z "${LDD+x}" ]; then
21592     # The variable is not set by user, try to locate tool using the code snippet
21593     for ac_prog in ldd
21594 do
21595   # Extract the first word of "$ac_prog", so it can be a program name with args.
21596 set dummy $ac_prog; ac_word=$2
21597 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21598 $as_echo_n "checking for $ac_word... " >&6; }
21599 if ${ac_cv_path_LDD+:} false; then :
21600   $as_echo_n "(cached) " >&6
21601 else
21602   case $LDD in
21603   [\\/]* | ?:[\\/]*)
21604   ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
21605   ;;
21606   *)
21607   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21608 for as_dir in $PATH
21609 do
21610   IFS=$as_save_IFS
21611   test -z "$as_dir" && as_dir=.
21612     for ac_exec_ext in '' $ac_executable_extensions; do
21613   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21614     ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
21615     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21616     break 2
21617   fi
21618 done
21619   done
21620 IFS=$as_save_IFS
21621 
21622   ;;
21623 esac
21624 fi
21625 LDD=$ac_cv_path_LDD
21626 if test -n "$LDD"; then
21627   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
21628 $as_echo "$LDD" >&6; }
21629 else
21630   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21631 $as_echo "no" >&6; }
21632 fi
21633 
21634 
21635   test -n "$LDD" && break
21636 done
21637 
21638   else
21639     # The variable is set, but is it from the command line or the environment?
21640 
21641     # Try to remove the string !LDD! from our list.
21642     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LDD!/}
21643     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
21644       # If it failed, the variable was not from the command line. Ignore it,
21645       # but warn the user (except for BASH, which is always set by the calling BASH).
21646       if test "xLDD" != xBASH; then
21647         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LDD from the environment. Use command line variables instead." >&5
21648 $as_echo "$as_me: WARNING: Ignoring value of LDD from the environment. Use command line variables instead." >&2;}
21649       fi
21650       # Try to locate tool using the code snippet
21651       for ac_prog in ldd
21652 do
21653   # Extract the first word of "$ac_prog", so it can be a program name with args.
21654 set dummy $ac_prog; ac_word=$2
21655 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21656 $as_echo_n "checking for $ac_word... " >&6; }
21657 if ${ac_cv_path_LDD+:} false; then :
21658   $as_echo_n "(cached) " >&6
21659 else
21660   case $LDD in
21661   [\\/]* | ?:[\\/]*)
21662   ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
21663   ;;
21664   *)
21665   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21666 for as_dir in $PATH
21667 do
21668   IFS=$as_save_IFS
21669   test -z "$as_dir" && as_dir=.
21670     for ac_exec_ext in '' $ac_executable_extensions; do
21671   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21672     ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
21673     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21674     break 2
21675   fi
21676 done
21677   done
21678 IFS=$as_save_IFS
21679 
21680   ;;
21681 esac
21682 fi
21683 LDD=$ac_cv_path_LDD
21684 if test -n "$LDD"; then
21685   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
21686 $as_echo "$LDD" >&6; }
21687 else
21688   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21689 $as_echo "no" >&6; }
21690 fi
21691 
21692 
21693   test -n "$LDD" && break
21694 done
21695 
21696     else
21697       # If it succeeded, then it was overridden by the user. We will use it
21698       # for the tool.
21699 
21700       # First remove it from the list of overridden variables, so we can test
21701       # for unknown variables in the end.
21702       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
21703 
21704       # Check if we try to supply an empty value
21705       if test "x$LDD" = x; then
21706         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool LDD= (no value)" >&5
21707 $as_echo "$as_me: Setting user supplied tool LDD= (no value)" >&6;}
21708         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LDD" >&5
21709 $as_echo_n "checking for LDD... " >&6; }
21710         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
21711 $as_echo "disabled" >&6; }
21712       else
21713         # Check if the provided tool contains a complete path.
21714         tool_specified="$LDD"
21715         tool_basename="${tool_specified##*/}"
21716         if test "x$tool_basename" = "x$tool_specified"; then
21717           # A command without a complete path is provided, search $PATH.
21718           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LDD=$tool_basename" >&5
21719 $as_echo "$as_me: Will search for user supplied tool LDD=$tool_basename" >&6;}
21720           # Extract the first word of "$tool_basename", so it can be a program name with args.
21721 set dummy $tool_basename; ac_word=$2
21722 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21723 $as_echo_n "checking for $ac_word... " >&6; }
21724 if ${ac_cv_path_LDD+:} false; then :
21725   $as_echo_n "(cached) " >&6
21726 else
21727   case $LDD in
21728   [\\/]* | ?:[\\/]*)
21729   ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
21730   ;;
21731   *)
21732   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21733 for as_dir in $PATH
21734 do
21735   IFS=$as_save_IFS
21736   test -z "$as_dir" && as_dir=.
21737     for ac_exec_ext in '' $ac_executable_extensions; do
21738   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21739     ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
21740     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21741     break 2
21742   fi
21743 done
21744   done
21745 IFS=$as_save_IFS
21746 
21747   ;;
21748 esac
21749 fi
21750 LDD=$ac_cv_path_LDD
21751 if test -n "$LDD"; then
21752   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
21753 $as_echo "$LDD" >&6; }
21754 else
21755   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21756 $as_echo "no" >&6; }
21757 fi
21758 
21759 
21760           if test "x$LDD" = x; then
21761             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
21762           fi
21763         else
21764           # Otherwise we believe it is a complete path. Use it as it is.
21765           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LDD=$tool_specified" >&5
21766 $as_echo "$as_me: Will use user supplied tool LDD=$tool_specified" >&6;}
21767           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LDD" >&5
21768 $as_echo_n "checking for LDD... " >&6; }
21769           if test ! -x "$tool_specified"; then
21770             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
21771 $as_echo "not found" >&6; }
21772             as_fn_error $? "User supplied tool LDD=$tool_specified does not exist or is not executable" "$LINENO" 5
21773           fi
21774           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
21775 $as_echo "$tool_specified" >&6; }
21776         fi
21777       fi
21778     fi
21779 
21780   fi
21781 
21782 
21783   if test "x$LDD" = "x"; then
21784     # List shared lib dependencies is used for
21785     # debug output and checking for forbidden dependencies.
21786     # We can build without it.
21787     LDD="true"
21788   fi
21789 
21790 
21791   # Publish this variable in the help.
21792 
21793 
21794   if [ -z "${OTOOL+x}" ]; then
21795     # The variable is not set by user, try to locate tool using the code snippet
21796     for ac_prog in otool
21797 do
21798   # Extract the first word of "$ac_prog", so it can be a program name with args.
21799 set dummy $ac_prog; ac_word=$2
21800 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21801 $as_echo_n "checking for $ac_word... " >&6; }
21802 if ${ac_cv_path_OTOOL+:} false; then :
21803   $as_echo_n "(cached) " >&6
21804 else
21805   case $OTOOL in
21806   [\\/]* | ?:[\\/]*)
21807   ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
21808   ;;
21809   *)
21810   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21811 for as_dir in $PATH
21812 do
21813   IFS=$as_save_IFS
21814   test -z "$as_dir" && as_dir=.
21815     for ac_exec_ext in '' $ac_executable_extensions; do
21816   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21817     ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
21818     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21819     break 2
21820   fi
21821 done
21822   done
21823 IFS=$as_save_IFS
21824 
21825   ;;
21826 esac
21827 fi
21828 OTOOL=$ac_cv_path_OTOOL
21829 if test -n "$OTOOL"; then
21830   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
21831 $as_echo "$OTOOL" >&6; }
21832 else
21833   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21834 $as_echo "no" >&6; }
21835 fi
21836 
21837 
21838   test -n "$OTOOL" && break
21839 done
21840 
21841   else
21842     # The variable is set, but is it from the command line or the environment?
21843 
21844     # Try to remove the string !OTOOL! from our list.
21845     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!OTOOL!/}
21846     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
21847       # If it failed, the variable was not from the command line. Ignore it,
21848       # but warn the user (except for BASH, which is always set by the calling BASH).
21849       if test "xOTOOL" != xBASH; then
21850         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of OTOOL from the environment. Use command line variables instead." >&5
21851 $as_echo "$as_me: WARNING: Ignoring value of OTOOL from the environment. Use command line variables instead." >&2;}
21852       fi
21853       # Try to locate tool using the code snippet
21854       for ac_prog in otool
21855 do
21856   # Extract the first word of "$ac_prog", so it can be a program name with args.
21857 set dummy $ac_prog; ac_word=$2
21858 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21859 $as_echo_n "checking for $ac_word... " >&6; }
21860 if ${ac_cv_path_OTOOL+:} false; then :
21861   $as_echo_n "(cached) " >&6
21862 else
21863   case $OTOOL in
21864   [\\/]* | ?:[\\/]*)
21865   ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
21866   ;;
21867   *)
21868   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21869 for as_dir in $PATH
21870 do
21871   IFS=$as_save_IFS
21872   test -z "$as_dir" && as_dir=.
21873     for ac_exec_ext in '' $ac_executable_extensions; do
21874   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21875     ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
21876     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21877     break 2
21878   fi
21879 done
21880   done
21881 IFS=$as_save_IFS
21882 
21883   ;;
21884 esac
21885 fi
21886 OTOOL=$ac_cv_path_OTOOL
21887 if test -n "$OTOOL"; then
21888   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
21889 $as_echo "$OTOOL" >&6; }
21890 else
21891   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21892 $as_echo "no" >&6; }
21893 fi
21894 
21895 
21896   test -n "$OTOOL" && break
21897 done
21898 
21899     else
21900       # If it succeeded, then it was overridden by the user. We will use it
21901       # for the tool.
21902 
21903       # First remove it from the list of overridden variables, so we can test
21904       # for unknown variables in the end.
21905       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
21906 
21907       # Check if we try to supply an empty value
21908       if test "x$OTOOL" = x; then
21909         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool OTOOL= (no value)" >&5
21910 $as_echo "$as_me: Setting user supplied tool OTOOL= (no value)" >&6;}
21911         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for OTOOL" >&5
21912 $as_echo_n "checking for OTOOL... " >&6; }
21913         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
21914 $as_echo "disabled" >&6; }
21915       else
21916         # Check if the provided tool contains a complete path.
21917         tool_specified="$OTOOL"
21918         tool_basename="${tool_specified##*/}"
21919         if test "x$tool_basename" = "x$tool_specified"; then
21920           # A command without a complete path is provided, search $PATH.
21921           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool OTOOL=$tool_basename" >&5
21922 $as_echo "$as_me: Will search for user supplied tool OTOOL=$tool_basename" >&6;}
21923           # Extract the first word of "$tool_basename", so it can be a program name with args.
21924 set dummy $tool_basename; ac_word=$2
21925 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21926 $as_echo_n "checking for $ac_word... " >&6; }
21927 if ${ac_cv_path_OTOOL+:} false; then :
21928   $as_echo_n "(cached) " >&6
21929 else
21930   case $OTOOL in
21931   [\\/]* | ?:[\\/]*)
21932   ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
21933   ;;
21934   *)
21935   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21936 for as_dir in $PATH
21937 do
21938   IFS=$as_save_IFS
21939   test -z "$as_dir" && as_dir=.
21940     for ac_exec_ext in '' $ac_executable_extensions; do
21941   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21942     ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
21943     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21944     break 2
21945   fi
21946 done
21947   done
21948 IFS=$as_save_IFS
21949 
21950   ;;
21951 esac
21952 fi
21953 OTOOL=$ac_cv_path_OTOOL
21954 if test -n "$OTOOL"; then
21955   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
21956 $as_echo "$OTOOL" >&6; }
21957 else
21958   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21959 $as_echo "no" >&6; }
21960 fi
21961 
21962 
21963           if test "x$OTOOL" = x; then
21964             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
21965           fi
21966         else
21967           # Otherwise we believe it is a complete path. Use it as it is.
21968           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool OTOOL=$tool_specified" >&5
21969 $as_echo "$as_me: Will use user supplied tool OTOOL=$tool_specified" >&6;}
21970           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for OTOOL" >&5
21971 $as_echo_n "checking for OTOOL... " >&6; }
21972           if test ! -x "$tool_specified"; then
21973             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
21974 $as_echo "not found" >&6; }
21975             as_fn_error $? "User supplied tool OTOOL=$tool_specified does not exist or is not executable" "$LINENO" 5
21976           fi
21977           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
21978 $as_echo "$tool_specified" >&6; }
21979         fi
21980       fi
21981     fi
21982 
21983   fi
21984 
21985 
21986   if test "x$OTOOL" = "x"; then
21987     OTOOL="true"
21988   fi
21989 
21990 
21991   # Publish this variable in the help.
21992 
21993 
21994   if [ -z "${READELF+x}" ]; then
21995     # The variable is not set by user, try to locate tool using the code snippet
21996     for ac_prog in greadelf readelf
21997 do
21998   # Extract the first word of "$ac_prog", so it can be a program name with args.
21999 set dummy $ac_prog; ac_word=$2
22000 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22001 $as_echo_n "checking for $ac_word... " >&6; }
22002 if ${ac_cv_path_READELF+:} false; then :
22003   $as_echo_n "(cached) " >&6
22004 else
22005   case $READELF in
22006   [\\/]* | ?:[\\/]*)
22007   ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
22008   ;;
22009   *)
22010   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22011 for as_dir in $PATH
22012 do
22013   IFS=$as_save_IFS
22014   test -z "$as_dir" && as_dir=.
22015     for ac_exec_ext in '' $ac_executable_extensions; do
22016   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22017     ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
22018     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22019     break 2
22020   fi
22021 done
22022   done
22023 IFS=$as_save_IFS
22024 
22025   ;;
22026 esac
22027 fi
22028 READELF=$ac_cv_path_READELF
22029 if test -n "$READELF"; then
22030   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
22031 $as_echo "$READELF" >&6; }
22032 else
22033   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22034 $as_echo "no" >&6; }
22035 fi
22036 
22037 
22038   test -n "$READELF" && break
22039 done
22040 
22041   else
22042     # The variable is set, but is it from the command line or the environment?
22043 
22044     # Try to remove the string !READELF! from our list.
22045     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!READELF!/}
22046     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
22047       # If it failed, the variable was not from the command line. Ignore it,
22048       # but warn the user (except for BASH, which is always set by the calling BASH).
22049       if test "xREADELF" != xBASH; then
22050         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of READELF from the environment. Use command line variables instead." >&5
22051 $as_echo "$as_me: WARNING: Ignoring value of READELF from the environment. Use command line variables instead." >&2;}
22052       fi
22053       # Try to locate tool using the code snippet
22054       for ac_prog in greadelf readelf
22055 do
22056   # Extract the first word of "$ac_prog", so it can be a program name with args.
22057 set dummy $ac_prog; ac_word=$2
22058 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22059 $as_echo_n "checking for $ac_word... " >&6; }
22060 if ${ac_cv_path_READELF+:} false; then :
22061   $as_echo_n "(cached) " >&6
22062 else
22063   case $READELF in
22064   [\\/]* | ?:[\\/]*)
22065   ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
22066   ;;
22067   *)
22068   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22069 for as_dir in $PATH
22070 do
22071   IFS=$as_save_IFS
22072   test -z "$as_dir" && as_dir=.
22073     for ac_exec_ext in '' $ac_executable_extensions; do
22074   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22075     ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
22076     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22077     break 2
22078   fi
22079 done
22080   done
22081 IFS=$as_save_IFS
22082 
22083   ;;
22084 esac
22085 fi
22086 READELF=$ac_cv_path_READELF
22087 if test -n "$READELF"; then
22088   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
22089 $as_echo "$READELF" >&6; }
22090 else
22091   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22092 $as_echo "no" >&6; }
22093 fi
22094 
22095 
22096   test -n "$READELF" && break
22097 done
22098 
22099     else
22100       # If it succeeded, then it was overridden by the user. We will use it
22101       # for the tool.
22102 
22103       # First remove it from the list of overridden variables, so we can test
22104       # for unknown variables in the end.
22105       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
22106 
22107       # Check if we try to supply an empty value
22108       if test "x$READELF" = x; then
22109         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool READELF= (no value)" >&5
22110 $as_echo "$as_me: Setting user supplied tool READELF= (no value)" >&6;}
22111         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READELF" >&5
22112 $as_echo_n "checking for READELF... " >&6; }
22113         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
22114 $as_echo "disabled" >&6; }
22115       else
22116         # Check if the provided tool contains a complete path.
22117         tool_specified="$READELF"
22118         tool_basename="${tool_specified##*/}"
22119         if test "x$tool_basename" = "x$tool_specified"; then
22120           # A command without a complete path is provided, search $PATH.
22121           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool READELF=$tool_basename" >&5
22122 $as_echo "$as_me: Will search for user supplied tool READELF=$tool_basename" >&6;}
22123           # Extract the first word of "$tool_basename", so it can be a program name with args.
22124 set dummy $tool_basename; ac_word=$2
22125 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22126 $as_echo_n "checking for $ac_word... " >&6; }
22127 if ${ac_cv_path_READELF+:} false; then :
22128   $as_echo_n "(cached) " >&6
22129 else
22130   case $READELF in
22131   [\\/]* | ?:[\\/]*)
22132   ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
22133   ;;
22134   *)
22135   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22136 for as_dir in $PATH
22137 do
22138   IFS=$as_save_IFS
22139   test -z "$as_dir" && as_dir=.
22140     for ac_exec_ext in '' $ac_executable_extensions; do
22141   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22142     ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
22143     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22144     break 2
22145   fi
22146 done
22147   done
22148 IFS=$as_save_IFS
22149 
22150   ;;
22151 esac
22152 fi
22153 READELF=$ac_cv_path_READELF
22154 if test -n "$READELF"; then
22155   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
22156 $as_echo "$READELF" >&6; }
22157 else
22158   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22159 $as_echo "no" >&6; }
22160 fi
22161 
22162 
22163           if test "x$READELF" = x; then
22164             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
22165           fi
22166         else
22167           # Otherwise we believe it is a complete path. Use it as it is.
22168           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool READELF=$tool_specified" >&5
22169 $as_echo "$as_me: Will use user supplied tool READELF=$tool_specified" >&6;}
22170           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READELF" >&5
22171 $as_echo_n "checking for READELF... " >&6; }
22172           if test ! -x "$tool_specified"; then
22173             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
22174 $as_echo "not found" >&6; }
22175             as_fn_error $? "User supplied tool READELF=$tool_specified does not exist or is not executable" "$LINENO" 5
22176           fi
22177           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
22178 $as_echo "$tool_specified" >&6; }
22179         fi
22180       fi
22181     fi
22182 
22183   fi
22184 
22185 
22186 
22187 
22188   # Publish this variable in the help.
22189 
22190 
22191   if [ -z "${HG+x}" ]; then
22192     # The variable is not set by user, try to locate tool using the code snippet
22193     for ac_prog in hg
22194 do
22195   # Extract the first word of "$ac_prog", so it can be a program name with args.
22196 set dummy $ac_prog; ac_word=$2
22197 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22198 $as_echo_n "checking for $ac_word... " >&6; }
22199 if ${ac_cv_path_HG+:} false; then :
22200   $as_echo_n "(cached) " >&6
22201 else
22202   case $HG in
22203   [\\/]* | ?:[\\/]*)
22204   ac_cv_path_HG="$HG" # Let the user override the test with a path.
22205   ;;
22206   *)
22207   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22208 for as_dir in $PATH
22209 do
22210   IFS=$as_save_IFS
22211   test -z "$as_dir" && as_dir=.
22212     for ac_exec_ext in '' $ac_executable_extensions; do
22213   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22214     ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
22215     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22216     break 2
22217   fi
22218 done
22219   done
22220 IFS=$as_save_IFS
22221 
22222   ;;
22223 esac
22224 fi
22225 HG=$ac_cv_path_HG
22226 if test -n "$HG"; then
22227   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
22228 $as_echo "$HG" >&6; }
22229 else
22230   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22231 $as_echo "no" >&6; }
22232 fi
22233 
22234 
22235   test -n "$HG" && break
22236 done
22237 
22238   else
22239     # The variable is set, but is it from the command line or the environment?
22240 
22241     # Try to remove the string !HG! from our list.
22242     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!HG!/}
22243     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
22244       # If it failed, the variable was not from the command line. Ignore it,
22245       # but warn the user (except for BASH, which is always set by the calling BASH).
22246       if test "xHG" != xBASH; then
22247         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of HG from the environment. Use command line variables instead." >&5
22248 $as_echo "$as_me: WARNING: Ignoring value of HG from the environment. Use command line variables instead." >&2;}
22249       fi
22250       # Try to locate tool using the code snippet
22251       for ac_prog in hg
22252 do
22253   # Extract the first word of "$ac_prog", so it can be a program name with args.
22254 set dummy $ac_prog; ac_word=$2
22255 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22256 $as_echo_n "checking for $ac_word... " >&6; }
22257 if ${ac_cv_path_HG+:} false; then :
22258   $as_echo_n "(cached) " >&6
22259 else
22260   case $HG in
22261   [\\/]* | ?:[\\/]*)
22262   ac_cv_path_HG="$HG" # Let the user override the test with a path.
22263   ;;
22264   *)
22265   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22266 for as_dir in $PATH
22267 do
22268   IFS=$as_save_IFS
22269   test -z "$as_dir" && as_dir=.
22270     for ac_exec_ext in '' $ac_executable_extensions; do
22271   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22272     ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
22273     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22274     break 2
22275   fi
22276 done
22277   done
22278 IFS=$as_save_IFS
22279 
22280   ;;
22281 esac
22282 fi
22283 HG=$ac_cv_path_HG
22284 if test -n "$HG"; then
22285   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
22286 $as_echo "$HG" >&6; }
22287 else
22288   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22289 $as_echo "no" >&6; }
22290 fi
22291 
22292 
22293   test -n "$HG" && break
22294 done
22295 
22296     else
22297       # If it succeeded, then it was overridden by the user. We will use it
22298       # for the tool.
22299 
22300       # First remove it from the list of overridden variables, so we can test
22301       # for unknown variables in the end.
22302       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
22303 
22304       # Check if we try to supply an empty value
22305       if test "x$HG" = x; then
22306         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool HG= (no value)" >&5
22307 $as_echo "$as_me: Setting user supplied tool HG= (no value)" >&6;}
22308         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HG" >&5
22309 $as_echo_n "checking for HG... " >&6; }
22310         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
22311 $as_echo "disabled" >&6; }
22312       else
22313         # Check if the provided tool contains a complete path.
22314         tool_specified="$HG"
22315         tool_basename="${tool_specified##*/}"
22316         if test "x$tool_basename" = "x$tool_specified"; then
22317           # A command without a complete path is provided, search $PATH.
22318           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool HG=$tool_basename" >&5
22319 $as_echo "$as_me: Will search for user supplied tool HG=$tool_basename" >&6;}
22320           # Extract the first word of "$tool_basename", so it can be a program name with args.
22321 set dummy $tool_basename; ac_word=$2
22322 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22323 $as_echo_n "checking for $ac_word... " >&6; }
22324 if ${ac_cv_path_HG+:} false; then :
22325   $as_echo_n "(cached) " >&6
22326 else
22327   case $HG in
22328   [\\/]* | ?:[\\/]*)
22329   ac_cv_path_HG="$HG" # Let the user override the test with a path.
22330   ;;
22331   *)
22332   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22333 for as_dir in $PATH
22334 do
22335   IFS=$as_save_IFS
22336   test -z "$as_dir" && as_dir=.
22337     for ac_exec_ext in '' $ac_executable_extensions; do
22338   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22339     ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
22340     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22341     break 2
22342   fi
22343 done
22344   done
22345 IFS=$as_save_IFS
22346 
22347   ;;
22348 esac
22349 fi
22350 HG=$ac_cv_path_HG
22351 if test -n "$HG"; then
22352   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
22353 $as_echo "$HG" >&6; }
22354 else
22355   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22356 $as_echo "no" >&6; }
22357 fi
22358 
22359 
22360           if test "x$HG" = x; then
22361             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
22362           fi
22363         else
22364           # Otherwise we believe it is a complete path. Use it as it is.
22365           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool HG=$tool_specified" >&5
22366 $as_echo "$as_me: Will use user supplied tool HG=$tool_specified" >&6;}
22367           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HG" >&5
22368 $as_echo_n "checking for HG... " >&6; }
22369           if test ! -x "$tool_specified"; then
22370             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
22371 $as_echo "not found" >&6; }
22372             as_fn_error $? "User supplied tool HG=$tool_specified does not exist or is not executable" "$LINENO" 5
22373           fi
22374           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
22375 $as_echo "$tool_specified" >&6; }
22376         fi
22377       fi
22378     fi
22379 
22380   fi
22381 
22382 
22383 
22384 
22385   # Publish this variable in the help.
22386 
22387 
22388   if [ -z "${STAT+x}" ]; then
22389     # The variable is not set by user, try to locate tool using the code snippet
22390     for ac_prog in stat
22391 do
22392   # Extract the first word of "$ac_prog", so it can be a program name with args.
22393 set dummy $ac_prog; ac_word=$2
22394 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22395 $as_echo_n "checking for $ac_word... " >&6; }
22396 if ${ac_cv_path_STAT+:} false; then :
22397   $as_echo_n "(cached) " >&6
22398 else
22399   case $STAT in
22400   [\\/]* | ?:[\\/]*)
22401   ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
22402   ;;
22403   *)
22404   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22405 for as_dir in $PATH
22406 do
22407   IFS=$as_save_IFS
22408   test -z "$as_dir" && as_dir=.
22409     for ac_exec_ext in '' $ac_executable_extensions; do
22410   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22411     ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
22412     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22413     break 2
22414   fi
22415 done
22416   done
22417 IFS=$as_save_IFS
22418 
22419   ;;
22420 esac
22421 fi
22422 STAT=$ac_cv_path_STAT
22423 if test -n "$STAT"; then
22424   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
22425 $as_echo "$STAT" >&6; }
22426 else
22427   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22428 $as_echo "no" >&6; }
22429 fi
22430 
22431 
22432   test -n "$STAT" && break
22433 done
22434 
22435   else
22436     # The variable is set, but is it from the command line or the environment?
22437 
22438     # Try to remove the string !STAT! from our list.
22439     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!STAT!/}
22440     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
22441       # If it failed, the variable was not from the command line. Ignore it,
22442       # but warn the user (except for BASH, which is always set by the calling BASH).
22443       if test "xSTAT" != xBASH; then
22444         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of STAT from the environment. Use command line variables instead." >&5
22445 $as_echo "$as_me: WARNING: Ignoring value of STAT from the environment. Use command line variables instead." >&2;}
22446       fi
22447       # Try to locate tool using the code snippet
22448       for ac_prog in stat
22449 do
22450   # Extract the first word of "$ac_prog", so it can be a program name with args.
22451 set dummy $ac_prog; ac_word=$2
22452 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22453 $as_echo_n "checking for $ac_word... " >&6; }
22454 if ${ac_cv_path_STAT+:} false; then :
22455   $as_echo_n "(cached) " >&6
22456 else
22457   case $STAT in
22458   [\\/]* | ?:[\\/]*)
22459   ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
22460   ;;
22461   *)
22462   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22463 for as_dir in $PATH
22464 do
22465   IFS=$as_save_IFS
22466   test -z "$as_dir" && as_dir=.
22467     for ac_exec_ext in '' $ac_executable_extensions; do
22468   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22469     ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
22470     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22471     break 2
22472   fi
22473 done
22474   done
22475 IFS=$as_save_IFS
22476 
22477   ;;
22478 esac
22479 fi
22480 STAT=$ac_cv_path_STAT
22481 if test -n "$STAT"; then
22482   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
22483 $as_echo "$STAT" >&6; }
22484 else
22485   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22486 $as_echo "no" >&6; }
22487 fi
22488 
22489 
22490   test -n "$STAT" && break
22491 done
22492 
22493     else
22494       # If it succeeded, then it was overridden by the user. We will use it
22495       # for the tool.
22496 
22497       # First remove it from the list of overridden variables, so we can test
22498       # for unknown variables in the end.
22499       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
22500 
22501       # Check if we try to supply an empty value
22502       if test "x$STAT" = x; then
22503         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool STAT= (no value)" >&5
22504 $as_echo "$as_me: Setting user supplied tool STAT= (no value)" >&6;}
22505         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for STAT" >&5
22506 $as_echo_n "checking for STAT... " >&6; }
22507         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
22508 $as_echo "disabled" >&6; }
22509       else
22510         # Check if the provided tool contains a complete path.
22511         tool_specified="$STAT"
22512         tool_basename="${tool_specified##*/}"
22513         if test "x$tool_basename" = "x$tool_specified"; then
22514           # A command without a complete path is provided, search $PATH.
22515           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool STAT=$tool_basename" >&5
22516 $as_echo "$as_me: Will search for user supplied tool STAT=$tool_basename" >&6;}
22517           # Extract the first word of "$tool_basename", so it can be a program name with args.
22518 set dummy $tool_basename; ac_word=$2
22519 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22520 $as_echo_n "checking for $ac_word... " >&6; }
22521 if ${ac_cv_path_STAT+:} false; then :
22522   $as_echo_n "(cached) " >&6
22523 else
22524   case $STAT in
22525   [\\/]* | ?:[\\/]*)
22526   ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
22527   ;;
22528   *)
22529   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22530 for as_dir in $PATH
22531 do
22532   IFS=$as_save_IFS
22533   test -z "$as_dir" && as_dir=.
22534     for ac_exec_ext in '' $ac_executable_extensions; do
22535   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22536     ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
22537     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22538     break 2
22539   fi
22540 done
22541   done
22542 IFS=$as_save_IFS
22543 
22544   ;;
22545 esac
22546 fi
22547 STAT=$ac_cv_path_STAT
22548 if test -n "$STAT"; then
22549   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
22550 $as_echo "$STAT" >&6; }
22551 else
22552   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22553 $as_echo "no" >&6; }
22554 fi
22555 
22556 
22557           if test "x$STAT" = x; then
22558             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
22559           fi
22560         else
22561           # Otherwise we believe it is a complete path. Use it as it is.
22562           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool STAT=$tool_specified" >&5
22563 $as_echo "$as_me: Will use user supplied tool STAT=$tool_specified" >&6;}
22564           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for STAT" >&5
22565 $as_echo_n "checking for STAT... " >&6; }
22566           if test ! -x "$tool_specified"; then
22567             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
22568 $as_echo "not found" >&6; }
22569             as_fn_error $? "User supplied tool STAT=$tool_specified does not exist or is not executable" "$LINENO" 5
22570           fi
22571           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
22572 $as_echo "$tool_specified" >&6; }
22573         fi
22574       fi
22575     fi
22576 
22577   fi
22578 
22579 
22580 
22581 
22582   # Publish this variable in the help.
22583 
22584 
22585   if [ -z "${TIME+x}" ]; then
22586     # The variable is not set by user, try to locate tool using the code snippet
22587     for ac_prog in time
22588 do
22589   # Extract the first word of "$ac_prog", so it can be a program name with args.
22590 set dummy $ac_prog; ac_word=$2
22591 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22592 $as_echo_n "checking for $ac_word... " >&6; }
22593 if ${ac_cv_path_TIME+:} false; then :
22594   $as_echo_n "(cached) " >&6
22595 else
22596   case $TIME in
22597   [\\/]* | ?:[\\/]*)
22598   ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
22599   ;;
22600   *)
22601   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22602 for as_dir in $PATH
22603 do
22604   IFS=$as_save_IFS
22605   test -z "$as_dir" && as_dir=.
22606     for ac_exec_ext in '' $ac_executable_extensions; do
22607   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22608     ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
22609     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22610     break 2
22611   fi
22612 done
22613   done
22614 IFS=$as_save_IFS
22615 
22616   ;;
22617 esac
22618 fi
22619 TIME=$ac_cv_path_TIME
22620 if test -n "$TIME"; then
22621   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
22622 $as_echo "$TIME" >&6; }
22623 else
22624   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22625 $as_echo "no" >&6; }
22626 fi
22627 
22628 
22629   test -n "$TIME" && break
22630 done
22631 
22632   else
22633     # The variable is set, but is it from the command line or the environment?
22634 
22635     # Try to remove the string !TIME! from our list.
22636     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TIME!/}
22637     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
22638       # If it failed, the variable was not from the command line. Ignore it,
22639       # but warn the user (except for BASH, which is always set by the calling BASH).
22640       if test "xTIME" != xBASH; then
22641         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TIME from the environment. Use command line variables instead." >&5
22642 $as_echo "$as_me: WARNING: Ignoring value of TIME from the environment. Use command line variables instead." >&2;}
22643       fi
22644       # Try to locate tool using the code snippet
22645       for ac_prog in time
22646 do
22647   # Extract the first word of "$ac_prog", so it can be a program name with args.
22648 set dummy $ac_prog; ac_word=$2
22649 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22650 $as_echo_n "checking for $ac_word... " >&6; }
22651 if ${ac_cv_path_TIME+:} false; then :
22652   $as_echo_n "(cached) " >&6
22653 else
22654   case $TIME in
22655   [\\/]* | ?:[\\/]*)
22656   ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
22657   ;;
22658   *)
22659   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22660 for as_dir in $PATH
22661 do
22662   IFS=$as_save_IFS
22663   test -z "$as_dir" && as_dir=.
22664     for ac_exec_ext in '' $ac_executable_extensions; do
22665   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22666     ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
22667     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22668     break 2
22669   fi
22670 done
22671   done
22672 IFS=$as_save_IFS
22673 
22674   ;;
22675 esac
22676 fi
22677 TIME=$ac_cv_path_TIME
22678 if test -n "$TIME"; then
22679   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
22680 $as_echo "$TIME" >&6; }
22681 else
22682   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22683 $as_echo "no" >&6; }
22684 fi
22685 
22686 
22687   test -n "$TIME" && break
22688 done
22689 
22690     else
22691       # If it succeeded, then it was overridden by the user. We will use it
22692       # for the tool.
22693 
22694       # First remove it from the list of overridden variables, so we can test
22695       # for unknown variables in the end.
22696       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
22697 
22698       # Check if we try to supply an empty value
22699       if test "x$TIME" = x; then
22700         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool TIME= (no value)" >&5
22701 $as_echo "$as_me: Setting user supplied tool TIME= (no value)" >&6;}
22702         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TIME" >&5
22703 $as_echo_n "checking for TIME... " >&6; }
22704         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
22705 $as_echo "disabled" >&6; }
22706       else
22707         # Check if the provided tool contains a complete path.
22708         tool_specified="$TIME"
22709         tool_basename="${tool_specified##*/}"
22710         if test "x$tool_basename" = "x$tool_specified"; then
22711           # A command without a complete path is provided, search $PATH.
22712           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TIME=$tool_basename" >&5
22713 $as_echo "$as_me: Will search for user supplied tool TIME=$tool_basename" >&6;}
22714           # Extract the first word of "$tool_basename", so it can be a program name with args.
22715 set dummy $tool_basename; ac_word=$2
22716 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22717 $as_echo_n "checking for $ac_word... " >&6; }
22718 if ${ac_cv_path_TIME+:} false; then :
22719   $as_echo_n "(cached) " >&6
22720 else
22721   case $TIME in
22722   [\\/]* | ?:[\\/]*)
22723   ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
22724   ;;
22725   *)
22726   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22727 for as_dir in $PATH
22728 do
22729   IFS=$as_save_IFS
22730   test -z "$as_dir" && as_dir=.
22731     for ac_exec_ext in '' $ac_executable_extensions; do
22732   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22733     ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
22734     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22735     break 2
22736   fi
22737 done
22738   done
22739 IFS=$as_save_IFS
22740 
22741   ;;
22742 esac
22743 fi
22744 TIME=$ac_cv_path_TIME
22745 if test -n "$TIME"; then
22746   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
22747 $as_echo "$TIME" >&6; }
22748 else
22749   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22750 $as_echo "no" >&6; }
22751 fi
22752 
22753 
22754           if test "x$TIME" = x; then
22755             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
22756           fi
22757         else
22758           # Otherwise we believe it is a complete path. Use it as it is.
22759           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TIME=$tool_specified" >&5
22760 $as_echo "$as_me: Will use user supplied tool TIME=$tool_specified" >&6;}
22761           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TIME" >&5
22762 $as_echo_n "checking for TIME... " >&6; }
22763           if test ! -x "$tool_specified"; then
22764             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
22765 $as_echo "not found" >&6; }
22766             as_fn_error $? "User supplied tool TIME=$tool_specified does not exist or is not executable" "$LINENO" 5
22767           fi
22768           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
22769 $as_echo "$tool_specified" >&6; }
22770         fi
22771       fi
22772     fi
22773 
22774   fi
22775 
22776 
22777 
22778 
22779   # Publish this variable in the help.
22780 
22781 
22782   if [ -z "${DTRACE+x}" ]; then
22783     # The variable is not set by user, try to locate tool using the code snippet
22784     for ac_prog in dtrace
22785 do
22786   # Extract the first word of "$ac_prog", so it can be a program name with args.
22787 set dummy $ac_prog; ac_word=$2
22788 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22789 $as_echo_n "checking for $ac_word... " >&6; }
22790 if ${ac_cv_path_DTRACE+:} false; then :
22791   $as_echo_n "(cached) " >&6
22792 else
22793   case $DTRACE in
22794   [\\/]* | ?:[\\/]*)
22795   ac_cv_path_DTRACE="$DTRACE" # Let the user override the test with a path.
22796   ;;
22797   *)
22798   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22799 for as_dir in $PATH
22800 do
22801   IFS=$as_save_IFS
22802   test -z "$as_dir" && as_dir=.
22803     for ac_exec_ext in '' $ac_executable_extensions; do
22804   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22805     ac_cv_path_DTRACE="$as_dir/$ac_word$ac_exec_ext"
22806     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22807     break 2
22808   fi
22809 done
22810   done
22811 IFS=$as_save_IFS
22812 
22813   ;;
22814 esac
22815 fi
22816 DTRACE=$ac_cv_path_DTRACE
22817 if test -n "$DTRACE"; then
22818   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DTRACE" >&5
22819 $as_echo "$DTRACE" >&6; }
22820 else
22821   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22822 $as_echo "no" >&6; }
22823 fi
22824 
22825 
22826   test -n "$DTRACE" && break
22827 done
22828 
22829   else
22830     # The variable is set, but is it from the command line or the environment?
22831 
22832     # Try to remove the string !DTRACE! from our list.
22833     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DTRACE!/}
22834     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
22835       # If it failed, the variable was not from the command line. Ignore it,
22836       # but warn the user (except for BASH, which is always set by the calling BASH).
22837       if test "xDTRACE" != xBASH; then
22838         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DTRACE from the environment. Use command line variables instead." >&5
22839 $as_echo "$as_me: WARNING: Ignoring value of DTRACE from the environment. Use command line variables instead." >&2;}
22840       fi
22841       # Try to locate tool using the code snippet
22842       for ac_prog in dtrace
22843 do
22844   # Extract the first word of "$ac_prog", so it can be a program name with args.
22845 set dummy $ac_prog; ac_word=$2
22846 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22847 $as_echo_n "checking for $ac_word... " >&6; }
22848 if ${ac_cv_path_DTRACE+:} false; then :
22849   $as_echo_n "(cached) " >&6
22850 else
22851   case $DTRACE in
22852   [\\/]* | ?:[\\/]*)
22853   ac_cv_path_DTRACE="$DTRACE" # Let the user override the test with a path.
22854   ;;
22855   *)
22856   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22857 for as_dir in $PATH
22858 do
22859   IFS=$as_save_IFS
22860   test -z "$as_dir" && as_dir=.
22861     for ac_exec_ext in '' $ac_executable_extensions; do
22862   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22863     ac_cv_path_DTRACE="$as_dir/$ac_word$ac_exec_ext"
22864     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22865     break 2
22866   fi
22867 done
22868   done
22869 IFS=$as_save_IFS
22870 
22871   ;;
22872 esac
22873 fi
22874 DTRACE=$ac_cv_path_DTRACE
22875 if test -n "$DTRACE"; then
22876   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DTRACE" >&5
22877 $as_echo "$DTRACE" >&6; }
22878 else
22879   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22880 $as_echo "no" >&6; }
22881 fi
22882 
22883 
22884   test -n "$DTRACE" && break
22885 done
22886 
22887     else
22888       # If it succeeded, then it was overridden by the user. We will use it
22889       # for the tool.
22890 
22891       # First remove it from the list of overridden variables, so we can test
22892       # for unknown variables in the end.
22893       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
22894 
22895       # Check if we try to supply an empty value
22896       if test "x$DTRACE" = x; then
22897         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool DTRACE= (no value)" >&5
22898 $as_echo "$as_me: Setting user supplied tool DTRACE= (no value)" >&6;}
22899         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DTRACE" >&5
22900 $as_echo_n "checking for DTRACE... " >&6; }
22901         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
22902 $as_echo "disabled" >&6; }
22903       else
22904         # Check if the provided tool contains a complete path.
22905         tool_specified="$DTRACE"
22906         tool_basename="${tool_specified##*/}"
22907         if test "x$tool_basename" = "x$tool_specified"; then
22908           # A command without a complete path is provided, search $PATH.
22909           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DTRACE=$tool_basename" >&5
22910 $as_echo "$as_me: Will search for user supplied tool DTRACE=$tool_basename" >&6;}
22911           # Extract the first word of "$tool_basename", so it can be a program name with args.
22912 set dummy $tool_basename; ac_word=$2
22913 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22914 $as_echo_n "checking for $ac_word... " >&6; }
22915 if ${ac_cv_path_DTRACE+:} false; then :
22916   $as_echo_n "(cached) " >&6
22917 else
22918   case $DTRACE in
22919   [\\/]* | ?:[\\/]*)
22920   ac_cv_path_DTRACE="$DTRACE" # Let the user override the test with a path.
22921   ;;
22922   *)
22923   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22924 for as_dir in $PATH
22925 do
22926   IFS=$as_save_IFS
22927   test -z "$as_dir" && as_dir=.
22928     for ac_exec_ext in '' $ac_executable_extensions; do
22929   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22930     ac_cv_path_DTRACE="$as_dir/$ac_word$ac_exec_ext"
22931     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22932     break 2
22933   fi
22934 done
22935   done
22936 IFS=$as_save_IFS
22937 
22938   ;;
22939 esac
22940 fi
22941 DTRACE=$ac_cv_path_DTRACE
22942 if test -n "$DTRACE"; then
22943   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DTRACE" >&5
22944 $as_echo "$DTRACE" >&6; }
22945 else
22946   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22947 $as_echo "no" >&6; }
22948 fi
22949 
22950 
22951           if test "x$DTRACE" = x; then
22952             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
22953           fi
22954         else
22955           # Otherwise we believe it is a complete path. Use it as it is.
22956           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DTRACE=$tool_specified" >&5
22957 $as_echo "$as_me: Will use user supplied tool DTRACE=$tool_specified" >&6;}
22958           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DTRACE" >&5
22959 $as_echo_n "checking for DTRACE... " >&6; }
22960           if test ! -x "$tool_specified"; then
22961             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
22962 $as_echo "not found" >&6; }
22963             as_fn_error $? "User supplied tool DTRACE=$tool_specified does not exist or is not executable" "$LINENO" 5
22964           fi
22965           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
22966 $as_echo "$tool_specified" >&6; }
22967         fi
22968       fi
22969     fi
22970 
22971   fi
22972 
22973 
22974 
22975 
22976   # Publish this variable in the help.
22977 
22978 
22979   if [ -z "${PATCH+x}" ]; then
22980     # The variable is not set by user, try to locate tool using the code snippet
22981     for ac_prog in gpatch patch
22982 do
22983   # Extract the first word of "$ac_prog", so it can be a program name with args.
22984 set dummy $ac_prog; ac_word=$2
22985 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22986 $as_echo_n "checking for $ac_word... " >&6; }
22987 if ${ac_cv_path_PATCH+:} false; then :
22988   $as_echo_n "(cached) " >&6
22989 else
22990   case $PATCH in
22991   [\\/]* | ?:[\\/]*)
22992   ac_cv_path_PATCH="$PATCH" # Let the user override the test with a path.
22993   ;;
22994   *)
22995   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22996 for as_dir in $PATH
22997 do
22998   IFS=$as_save_IFS
22999   test -z "$as_dir" && as_dir=.
23000     for ac_exec_ext in '' $ac_executable_extensions; do
23001   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23002     ac_cv_path_PATCH="$as_dir/$ac_word$ac_exec_ext"
23003     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23004     break 2
23005   fi
23006 done
23007   done
23008 IFS=$as_save_IFS
23009 
23010   ;;
23011 esac
23012 fi
23013 PATCH=$ac_cv_path_PATCH
23014 if test -n "$PATCH"; then
23015   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PATCH" >&5
23016 $as_echo "$PATCH" >&6; }
23017 else
23018   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23019 $as_echo "no" >&6; }
23020 fi
23021 
23022 
23023   test -n "$PATCH" && break
23024 done
23025 
23026   else
23027     # The variable is set, but is it from the command line or the environment?
23028 
23029     # Try to remove the string !PATCH! from our list.
23030     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!PATCH!/}
23031     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
23032       # If it failed, the variable was not from the command line. Ignore it,
23033       # but warn the user (except for BASH, which is always set by the calling BASH).
23034       if test "xPATCH" != xBASH; then
23035         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of PATCH from the environment. Use command line variables instead." >&5
23036 $as_echo "$as_me: WARNING: Ignoring value of PATCH from the environment. Use command line variables instead." >&2;}
23037       fi
23038       # Try to locate tool using the code snippet
23039       for ac_prog in gpatch patch
23040 do
23041   # Extract the first word of "$ac_prog", so it can be a program name with args.
23042 set dummy $ac_prog; ac_word=$2
23043 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23044 $as_echo_n "checking for $ac_word... " >&6; }
23045 if ${ac_cv_path_PATCH+:} false; then :
23046   $as_echo_n "(cached) " >&6
23047 else
23048   case $PATCH in
23049   [\\/]* | ?:[\\/]*)
23050   ac_cv_path_PATCH="$PATCH" # Let the user override the test with a path.
23051   ;;
23052   *)
23053   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23054 for as_dir in $PATH
23055 do
23056   IFS=$as_save_IFS
23057   test -z "$as_dir" && as_dir=.
23058     for ac_exec_ext in '' $ac_executable_extensions; do
23059   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23060     ac_cv_path_PATCH="$as_dir/$ac_word$ac_exec_ext"
23061     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23062     break 2
23063   fi
23064 done
23065   done
23066 IFS=$as_save_IFS
23067 
23068   ;;
23069 esac
23070 fi
23071 PATCH=$ac_cv_path_PATCH
23072 if test -n "$PATCH"; then
23073   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PATCH" >&5
23074 $as_echo "$PATCH" >&6; }
23075 else
23076   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23077 $as_echo "no" >&6; }
23078 fi
23079 
23080 
23081   test -n "$PATCH" && break
23082 done
23083 
23084     else
23085       # If it succeeded, then it was overridden by the user. We will use it
23086       # for the tool.
23087 
23088       # First remove it from the list of overridden variables, so we can test
23089       # for unknown variables in the end.
23090       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
23091 
23092       # Check if we try to supply an empty value
23093       if test "x$PATCH" = x; then
23094         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool PATCH= (no value)" >&5
23095 $as_echo "$as_me: Setting user supplied tool PATCH= (no value)" >&6;}
23096         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PATCH" >&5
23097 $as_echo_n "checking for PATCH... " >&6; }
23098         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
23099 $as_echo "disabled" >&6; }
23100       else
23101         # Check if the provided tool contains a complete path.
23102         tool_specified="$PATCH"
23103         tool_basename="${tool_specified##*/}"
23104         if test "x$tool_basename" = "x$tool_specified"; then
23105           # A command without a complete path is provided, search $PATH.
23106           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool PATCH=$tool_basename" >&5
23107 $as_echo "$as_me: Will search for user supplied tool PATCH=$tool_basename" >&6;}
23108           # Extract the first word of "$tool_basename", so it can be a program name with args.
23109 set dummy $tool_basename; ac_word=$2
23110 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23111 $as_echo_n "checking for $ac_word... " >&6; }
23112 if ${ac_cv_path_PATCH+:} false; then :
23113   $as_echo_n "(cached) " >&6
23114 else
23115   case $PATCH in
23116   [\\/]* | ?:[\\/]*)
23117   ac_cv_path_PATCH="$PATCH" # Let the user override the test with a path.
23118   ;;
23119   *)
23120   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23121 for as_dir in $PATH
23122 do
23123   IFS=$as_save_IFS
23124   test -z "$as_dir" && as_dir=.
23125     for ac_exec_ext in '' $ac_executable_extensions; do
23126   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23127     ac_cv_path_PATCH="$as_dir/$ac_word$ac_exec_ext"
23128     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23129     break 2
23130   fi
23131 done
23132   done
23133 IFS=$as_save_IFS
23134 
23135   ;;
23136 esac
23137 fi
23138 PATCH=$ac_cv_path_PATCH
23139 if test -n "$PATCH"; then
23140   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PATCH" >&5
23141 $as_echo "$PATCH" >&6; }
23142 else
23143   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23144 $as_echo "no" >&6; }
23145 fi
23146 
23147 
23148           if test "x$PATCH" = x; then
23149             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
23150           fi
23151         else
23152           # Otherwise we believe it is a complete path. Use it as it is.
23153           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool PATCH=$tool_specified" >&5
23154 $as_echo "$as_me: Will use user supplied tool PATCH=$tool_specified" >&6;}
23155           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PATCH" >&5
23156 $as_echo_n "checking for PATCH... " >&6; }
23157           if test ! -x "$tool_specified"; then
23158             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
23159 $as_echo "not found" >&6; }
23160             as_fn_error $? "User supplied tool PATCH=$tool_specified does not exist or is not executable" "$LINENO" 5
23161           fi
23162           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
23163 $as_echo "$tool_specified" >&6; }
23164         fi
23165       fi
23166     fi
23167 
23168   fi
23169 
23170 
23171   # Check if it's GNU time
23172   IS_GNU_TIME=`$TIME --version 2>&1 | $GREP 'GNU time'`
23173   if test "x$IS_GNU_TIME" != x; then
23174     IS_GNU_TIME=yes
23175   else
23176     IS_GNU_TIME=no
23177   fi
23178 
23179 
23180   if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
23181 
23182 
23183 
23184   # Publish this variable in the help.
23185 
23186 
23187   if [ -z "${DSYMUTIL+x}" ]; then
23188     # The variable is not set by user, try to locate tool using the code snippet
23189     for ac_prog in dsymutil
23190 do
23191   # Extract the first word of "$ac_prog", so it can be a program name with args.
23192 set dummy $ac_prog; ac_word=$2
23193 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23194 $as_echo_n "checking for $ac_word... " >&6; }
23195 if ${ac_cv_path_DSYMUTIL+:} false; then :
23196   $as_echo_n "(cached) " >&6
23197 else
23198   case $DSYMUTIL in
23199   [\\/]* | ?:[\\/]*)
23200   ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
23201   ;;
23202   *)
23203   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23204 for as_dir in $PATH
23205 do
23206   IFS=$as_save_IFS
23207   test -z "$as_dir" && as_dir=.
23208     for ac_exec_ext in '' $ac_executable_extensions; do
23209   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23210     ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
23211     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23212     break 2
23213   fi
23214 done
23215   done
23216 IFS=$as_save_IFS
23217 
23218   ;;
23219 esac
23220 fi
23221 DSYMUTIL=$ac_cv_path_DSYMUTIL
23222 if test -n "$DSYMUTIL"; then
23223   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
23224 $as_echo "$DSYMUTIL" >&6; }
23225 else
23226   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23227 $as_echo "no" >&6; }
23228 fi
23229 
23230 
23231   test -n "$DSYMUTIL" && break
23232 done
23233 
23234   else
23235     # The variable is set, but is it from the command line or the environment?
23236 
23237     # Try to remove the string !DSYMUTIL! from our list.
23238     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DSYMUTIL!/}
23239     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
23240       # If it failed, the variable was not from the command line. Ignore it,
23241       # but warn the user (except for BASH, which is always set by the calling BASH).
23242       if test "xDSYMUTIL" != xBASH; then
23243         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DSYMUTIL from the environment. Use command line variables instead." >&5
23244 $as_echo "$as_me: WARNING: Ignoring value of DSYMUTIL from the environment. Use command line variables instead." >&2;}
23245       fi
23246       # Try to locate tool using the code snippet
23247       for ac_prog in dsymutil
23248 do
23249   # Extract the first word of "$ac_prog", so it can be a program name with args.
23250 set dummy $ac_prog; ac_word=$2
23251 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23252 $as_echo_n "checking for $ac_word... " >&6; }
23253 if ${ac_cv_path_DSYMUTIL+:} false; then :
23254   $as_echo_n "(cached) " >&6
23255 else
23256   case $DSYMUTIL in
23257   [\\/]* | ?:[\\/]*)
23258   ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
23259   ;;
23260   *)
23261   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23262 for as_dir in $PATH
23263 do
23264   IFS=$as_save_IFS
23265   test -z "$as_dir" && as_dir=.
23266     for ac_exec_ext in '' $ac_executable_extensions; do
23267   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23268     ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
23269     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23270     break 2
23271   fi
23272 done
23273   done
23274 IFS=$as_save_IFS
23275 
23276   ;;
23277 esac
23278 fi
23279 DSYMUTIL=$ac_cv_path_DSYMUTIL
23280 if test -n "$DSYMUTIL"; then
23281   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
23282 $as_echo "$DSYMUTIL" >&6; }
23283 else
23284   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23285 $as_echo "no" >&6; }
23286 fi
23287 
23288 
23289   test -n "$DSYMUTIL" && break
23290 done
23291 
23292     else
23293       # If it succeeded, then it was overridden by the user. We will use it
23294       # for the tool.
23295 
23296       # First remove it from the list of overridden variables, so we can test
23297       # for unknown variables in the end.
23298       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
23299 
23300       # Check if we try to supply an empty value
23301       if test "x$DSYMUTIL" = x; then
23302         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool DSYMUTIL= (no value)" >&5
23303 $as_echo "$as_me: Setting user supplied tool DSYMUTIL= (no value)" >&6;}
23304         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DSYMUTIL" >&5
23305 $as_echo_n "checking for DSYMUTIL... " >&6; }
23306         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
23307 $as_echo "disabled" >&6; }
23308       else
23309         # Check if the provided tool contains a complete path.
23310         tool_specified="$DSYMUTIL"
23311         tool_basename="${tool_specified##*/}"
23312         if test "x$tool_basename" = "x$tool_specified"; then
23313           # A command without a complete path is provided, search $PATH.
23314           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DSYMUTIL=$tool_basename" >&5
23315 $as_echo "$as_me: Will search for user supplied tool DSYMUTIL=$tool_basename" >&6;}
23316           # Extract the first word of "$tool_basename", so it can be a program name with args.
23317 set dummy $tool_basename; ac_word=$2
23318 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23319 $as_echo_n "checking for $ac_word... " >&6; }
23320 if ${ac_cv_path_DSYMUTIL+:} false; then :
23321   $as_echo_n "(cached) " >&6
23322 else
23323   case $DSYMUTIL in
23324   [\\/]* | ?:[\\/]*)
23325   ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
23326   ;;
23327   *)
23328   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23329 for as_dir in $PATH
23330 do
23331   IFS=$as_save_IFS
23332   test -z "$as_dir" && as_dir=.
23333     for ac_exec_ext in '' $ac_executable_extensions; do
23334   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23335     ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
23336     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23337     break 2
23338   fi
23339 done
23340   done
23341 IFS=$as_save_IFS
23342 
23343   ;;
23344 esac
23345 fi
23346 DSYMUTIL=$ac_cv_path_DSYMUTIL
23347 if test -n "$DSYMUTIL"; then
23348   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
23349 $as_echo "$DSYMUTIL" >&6; }
23350 else
23351   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23352 $as_echo "no" >&6; }
23353 fi
23354 
23355 
23356           if test "x$DSYMUTIL" = x; then
23357             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
23358           fi
23359         else
23360           # Otherwise we believe it is a complete path. Use it as it is.
23361           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DSYMUTIL=$tool_specified" >&5
23362 $as_echo "$as_me: Will use user supplied tool DSYMUTIL=$tool_specified" >&6;}
23363           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DSYMUTIL" >&5
23364 $as_echo_n "checking for DSYMUTIL... " >&6; }
23365           if test ! -x "$tool_specified"; then
23366             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
23367 $as_echo "not found" >&6; }
23368             as_fn_error $? "User supplied tool DSYMUTIL=$tool_specified does not exist or is not executable" "$LINENO" 5
23369           fi
23370           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
23371 $as_echo "$tool_specified" >&6; }
23372         fi
23373       fi
23374     fi
23375 
23376   fi
23377 
23378 
23379 
23380   if test "x$DSYMUTIL" = x; then
23381     as_fn_error $? "Could not find required tool for DSYMUTIL" "$LINENO" 5
23382   fi
23383 
23384 
23385 
23386 
23387 
23388   # Publish this variable in the help.
23389 
23390 
23391   if [ -z "${XATTR+x}" ]; then
23392     # The variable is not set by user, try to locate tool using the code snippet
23393     for ac_prog in xattr
23394 do
23395   # Extract the first word of "$ac_prog", so it can be a program name with args.
23396 set dummy $ac_prog; ac_word=$2
23397 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23398 $as_echo_n "checking for $ac_word... " >&6; }
23399 if ${ac_cv_path_XATTR+:} false; then :
23400   $as_echo_n "(cached) " >&6
23401 else
23402   case $XATTR in
23403   [\\/]* | ?:[\\/]*)
23404   ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
23405   ;;
23406   *)
23407   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23408 for as_dir in $PATH
23409 do
23410   IFS=$as_save_IFS
23411   test -z "$as_dir" && as_dir=.
23412     for ac_exec_ext in '' $ac_executable_extensions; do
23413   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23414     ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
23415     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23416     break 2
23417   fi
23418 done
23419   done
23420 IFS=$as_save_IFS
23421 
23422   ;;
23423 esac
23424 fi
23425 XATTR=$ac_cv_path_XATTR
23426 if test -n "$XATTR"; then
23427   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
23428 $as_echo "$XATTR" >&6; }
23429 else
23430   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23431 $as_echo "no" >&6; }
23432 fi
23433 
23434 
23435   test -n "$XATTR" && break
23436 done
23437 
23438   else
23439     # The variable is set, but is it from the command line or the environment?
23440 
23441     # Try to remove the string !XATTR! from our list.
23442     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!XATTR!/}
23443     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
23444       # If it failed, the variable was not from the command line. Ignore it,
23445       # but warn the user (except for BASH, which is always set by the calling BASH).
23446       if test "xXATTR" != xBASH; then
23447         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of XATTR from the environment. Use command line variables instead." >&5
23448 $as_echo "$as_me: WARNING: Ignoring value of XATTR from the environment. Use command line variables instead." >&2;}
23449       fi
23450       # Try to locate tool using the code snippet
23451       for ac_prog in xattr
23452 do
23453   # Extract the first word of "$ac_prog", so it can be a program name with args.
23454 set dummy $ac_prog; ac_word=$2
23455 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23456 $as_echo_n "checking for $ac_word... " >&6; }
23457 if ${ac_cv_path_XATTR+:} false; then :
23458   $as_echo_n "(cached) " >&6
23459 else
23460   case $XATTR in
23461   [\\/]* | ?:[\\/]*)
23462   ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
23463   ;;
23464   *)
23465   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23466 for as_dir in $PATH
23467 do
23468   IFS=$as_save_IFS
23469   test -z "$as_dir" && as_dir=.
23470     for ac_exec_ext in '' $ac_executable_extensions; do
23471   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23472     ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
23473     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23474     break 2
23475   fi
23476 done
23477   done
23478 IFS=$as_save_IFS
23479 
23480   ;;
23481 esac
23482 fi
23483 XATTR=$ac_cv_path_XATTR
23484 if test -n "$XATTR"; then
23485   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
23486 $as_echo "$XATTR" >&6; }
23487 else
23488   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23489 $as_echo "no" >&6; }
23490 fi
23491 
23492 
23493   test -n "$XATTR" && break
23494 done
23495 
23496     else
23497       # If it succeeded, then it was overridden by the user. We will use it
23498       # for the tool.
23499 
23500       # First remove it from the list of overridden variables, so we can test
23501       # for unknown variables in the end.
23502       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
23503 
23504       # Check if we try to supply an empty value
23505       if test "x$XATTR" = x; then
23506         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool XATTR= (no value)" >&5
23507 $as_echo "$as_me: Setting user supplied tool XATTR= (no value)" >&6;}
23508         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XATTR" >&5
23509 $as_echo_n "checking for XATTR... " >&6; }
23510         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
23511 $as_echo "disabled" >&6; }
23512       else
23513         # Check if the provided tool contains a complete path.
23514         tool_specified="$XATTR"
23515         tool_basename="${tool_specified##*/}"
23516         if test "x$tool_basename" = "x$tool_specified"; then
23517           # A command without a complete path is provided, search $PATH.
23518           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool XATTR=$tool_basename" >&5
23519 $as_echo "$as_me: Will search for user supplied tool XATTR=$tool_basename" >&6;}
23520           # Extract the first word of "$tool_basename", so it can be a program name with args.
23521 set dummy $tool_basename; ac_word=$2
23522 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23523 $as_echo_n "checking for $ac_word... " >&6; }
23524 if ${ac_cv_path_XATTR+:} false; then :
23525   $as_echo_n "(cached) " >&6
23526 else
23527   case $XATTR in
23528   [\\/]* | ?:[\\/]*)
23529   ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
23530   ;;
23531   *)
23532   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23533 for as_dir in $PATH
23534 do
23535   IFS=$as_save_IFS
23536   test -z "$as_dir" && as_dir=.
23537     for ac_exec_ext in '' $ac_executable_extensions; do
23538   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23539     ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
23540     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23541     break 2
23542   fi
23543 done
23544   done
23545 IFS=$as_save_IFS
23546 
23547   ;;
23548 esac
23549 fi
23550 XATTR=$ac_cv_path_XATTR
23551 if test -n "$XATTR"; then
23552   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
23553 $as_echo "$XATTR" >&6; }
23554 else
23555   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23556 $as_echo "no" >&6; }
23557 fi
23558 
23559 
23560           if test "x$XATTR" = x; then
23561             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
23562           fi
23563         else
23564           # Otherwise we believe it is a complete path. Use it as it is.
23565           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool XATTR=$tool_specified" >&5
23566 $as_echo "$as_me: Will use user supplied tool XATTR=$tool_specified" >&6;}
23567           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XATTR" >&5
23568 $as_echo_n "checking for XATTR... " >&6; }
23569           if test ! -x "$tool_specified"; then
23570             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
23571 $as_echo "not found" >&6; }
23572             as_fn_error $? "User supplied tool XATTR=$tool_specified does not exist or is not executable" "$LINENO" 5
23573           fi
23574           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
23575 $as_echo "$tool_specified" >&6; }
23576         fi
23577       fi
23578     fi
23579 
23580   fi
23581 
23582 
23583 
23584   if test "x$XATTR" = x; then
23585     as_fn_error $? "Could not find required tool for XATTR" "$LINENO" 5
23586   fi
23587 
23588 
23589 
23590 
23591   # Publish this variable in the help.
23592 
23593 
23594   if [ -z "${CODESIGN+x}" ]; then
23595     # The variable is not set by user, try to locate tool using the code snippet
23596     for ac_prog in codesign
23597 do
23598   # Extract the first word of "$ac_prog", so it can be a program name with args.
23599 set dummy $ac_prog; ac_word=$2
23600 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23601 $as_echo_n "checking for $ac_word... " >&6; }
23602 if ${ac_cv_path_CODESIGN+:} false; then :
23603   $as_echo_n "(cached) " >&6
23604 else
23605   case $CODESIGN in
23606   [\\/]* | ?:[\\/]*)
23607   ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
23608   ;;
23609   *)
23610   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23611 for as_dir in $PATH
23612 do
23613   IFS=$as_save_IFS
23614   test -z "$as_dir" && as_dir=.
23615     for ac_exec_ext in '' $ac_executable_extensions; do
23616   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23617     ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
23618     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23619     break 2
23620   fi
23621 done
23622   done
23623 IFS=$as_save_IFS
23624 
23625   ;;
23626 esac
23627 fi
23628 CODESIGN=$ac_cv_path_CODESIGN
23629 if test -n "$CODESIGN"; then
23630   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
23631 $as_echo "$CODESIGN" >&6; }
23632 else
23633   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23634 $as_echo "no" >&6; }
23635 fi
23636 
23637 
23638   test -n "$CODESIGN" && break
23639 done
23640 
23641   else
23642     # The variable is set, but is it from the command line or the environment?
23643 
23644     # Try to remove the string !CODESIGN! from our list.
23645     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CODESIGN!/}
23646     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
23647       # If it failed, the variable was not from the command line. Ignore it,
23648       # but warn the user (except for BASH, which is always set by the calling BASH).
23649       if test "xCODESIGN" != xBASH; then
23650         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CODESIGN from the environment. Use command line variables instead." >&5
23651 $as_echo "$as_me: WARNING: Ignoring value of CODESIGN from the environment. Use command line variables instead." >&2;}
23652       fi
23653       # Try to locate tool using the code snippet
23654       for ac_prog in codesign
23655 do
23656   # Extract the first word of "$ac_prog", so it can be a program name with args.
23657 set dummy $ac_prog; ac_word=$2
23658 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23659 $as_echo_n "checking for $ac_word... " >&6; }
23660 if ${ac_cv_path_CODESIGN+:} false; then :
23661   $as_echo_n "(cached) " >&6
23662 else
23663   case $CODESIGN in
23664   [\\/]* | ?:[\\/]*)
23665   ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
23666   ;;
23667   *)
23668   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23669 for as_dir in $PATH
23670 do
23671   IFS=$as_save_IFS
23672   test -z "$as_dir" && as_dir=.
23673     for ac_exec_ext in '' $ac_executable_extensions; do
23674   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23675     ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
23676     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23677     break 2
23678   fi
23679 done
23680   done
23681 IFS=$as_save_IFS
23682 
23683   ;;
23684 esac
23685 fi
23686 CODESIGN=$ac_cv_path_CODESIGN
23687 if test -n "$CODESIGN"; then
23688   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
23689 $as_echo "$CODESIGN" >&6; }
23690 else
23691   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23692 $as_echo "no" >&6; }
23693 fi
23694 
23695 
23696   test -n "$CODESIGN" && break
23697 done
23698 
23699     else
23700       # If it succeeded, then it was overridden by the user. We will use it
23701       # for the tool.
23702 
23703       # First remove it from the list of overridden variables, so we can test
23704       # for unknown variables in the end.
23705       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
23706 
23707       # Check if we try to supply an empty value
23708       if test "x$CODESIGN" = x; then
23709         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CODESIGN= (no value)" >&5
23710 $as_echo "$as_me: Setting user supplied tool CODESIGN= (no value)" >&6;}
23711         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CODESIGN" >&5
23712 $as_echo_n "checking for CODESIGN... " >&6; }
23713         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
23714 $as_echo "disabled" >&6; }
23715       else
23716         # Check if the provided tool contains a complete path.
23717         tool_specified="$CODESIGN"
23718         tool_basename="${tool_specified##*/}"
23719         if test "x$tool_basename" = "x$tool_specified"; then
23720           # A command without a complete path is provided, search $PATH.
23721           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CODESIGN=$tool_basename" >&5
23722 $as_echo "$as_me: Will search for user supplied tool CODESIGN=$tool_basename" >&6;}
23723           # Extract the first word of "$tool_basename", so it can be a program name with args.
23724 set dummy $tool_basename; ac_word=$2
23725 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23726 $as_echo_n "checking for $ac_word... " >&6; }
23727 if ${ac_cv_path_CODESIGN+:} false; then :
23728   $as_echo_n "(cached) " >&6
23729 else
23730   case $CODESIGN in
23731   [\\/]* | ?:[\\/]*)
23732   ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
23733   ;;
23734   *)
23735   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23736 for as_dir in $PATH
23737 do
23738   IFS=$as_save_IFS
23739   test -z "$as_dir" && as_dir=.
23740     for ac_exec_ext in '' $ac_executable_extensions; do
23741   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23742     ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
23743     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23744     break 2
23745   fi
23746 done
23747   done
23748 IFS=$as_save_IFS
23749 
23750   ;;
23751 esac
23752 fi
23753 CODESIGN=$ac_cv_path_CODESIGN
23754 if test -n "$CODESIGN"; then
23755   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
23756 $as_echo "$CODESIGN" >&6; }
23757 else
23758   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23759 $as_echo "no" >&6; }
23760 fi
23761 
23762 
23763           if test "x$CODESIGN" = x; then
23764             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
23765           fi
23766         else
23767           # Otherwise we believe it is a complete path. Use it as it is.
23768           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CODESIGN=$tool_specified" >&5
23769 $as_echo "$as_me: Will use user supplied tool CODESIGN=$tool_specified" >&6;}
23770           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CODESIGN" >&5
23771 $as_echo_n "checking for CODESIGN... " >&6; }
23772           if test ! -x "$tool_specified"; then
23773             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
23774 $as_echo "not found" >&6; }
23775             as_fn_error $? "User supplied tool CODESIGN=$tool_specified does not exist or is not executable" "$LINENO" 5
23776           fi
23777           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
23778 $as_echo "$tool_specified" >&6; }
23779         fi
23780       fi
23781     fi
23782 
23783   fi
23784 
23785 
23786     if test "x$CODESIGN" != "x"; then
23787       # Verify that the openjdk_codesign certificate is present
23788       { $as_echo "$as_me:${as_lineno-$LINENO}: checking if openjdk_codesign certificate is present" >&5
23789 $as_echo_n "checking if openjdk_codesign certificate is present... " >&6; }
23790       $RM codesign-testfile
23791       $TOUCH codesign-testfile
23792       $CODESIGN -s openjdk_codesign codesign-testfile 2>&5 >&5 || CODESIGN=
23793       $RM codesign-testfile
23794       if test "x$CODESIGN" = x; then
23795         { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23796 $as_echo "no" >&6; }
23797       else
23798         { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
23799 $as_echo "yes" >&6; }
23800       fi
23801     fi
23802 
23803 
23804 
23805   # Publish this variable in the help.
23806 
23807 
23808   if [ -z "${SETFILE+x}" ]; then
23809     # The variable is not set by user, try to locate tool using the code snippet
23810     for ac_prog in SetFile
23811 do
23812   # Extract the first word of "$ac_prog", so it can be a program name with args.
23813 set dummy $ac_prog; ac_word=$2
23814 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23815 $as_echo_n "checking for $ac_word... " >&6; }
23816 if ${ac_cv_path_SETFILE+:} false; then :
23817   $as_echo_n "(cached) " >&6
23818 else
23819   case $SETFILE in
23820   [\\/]* | ?:[\\/]*)
23821   ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
23822   ;;
23823   *)
23824   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23825 for as_dir in $PATH
23826 do
23827   IFS=$as_save_IFS
23828   test -z "$as_dir" && as_dir=.
23829     for ac_exec_ext in '' $ac_executable_extensions; do
23830   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23831     ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
23832     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23833     break 2
23834   fi
23835 done
23836   done
23837 IFS=$as_save_IFS
23838 
23839   ;;
23840 esac
23841 fi
23842 SETFILE=$ac_cv_path_SETFILE
23843 if test -n "$SETFILE"; then
23844   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
23845 $as_echo "$SETFILE" >&6; }
23846 else
23847   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23848 $as_echo "no" >&6; }
23849 fi
23850 
23851 
23852   test -n "$SETFILE" && break
23853 done
23854 
23855   else
23856     # The variable is set, but is it from the command line or the environment?
23857 
23858     # Try to remove the string !SETFILE! from our list.
23859     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SETFILE!/}
23860     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
23861       # If it failed, the variable was not from the command line. Ignore it,
23862       # but warn the user (except for BASH, which is always set by the calling BASH).
23863       if test "xSETFILE" != xBASH; then
23864         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SETFILE from the environment. Use command line variables instead." >&5
23865 $as_echo "$as_me: WARNING: Ignoring value of SETFILE from the environment. Use command line variables instead." >&2;}
23866       fi
23867       # Try to locate tool using the code snippet
23868       for ac_prog in SetFile
23869 do
23870   # Extract the first word of "$ac_prog", so it can be a program name with args.
23871 set dummy $ac_prog; ac_word=$2
23872 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23873 $as_echo_n "checking for $ac_word... " >&6; }
23874 if ${ac_cv_path_SETFILE+:} false; then :
23875   $as_echo_n "(cached) " >&6
23876 else
23877   case $SETFILE in
23878   [\\/]* | ?:[\\/]*)
23879   ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
23880   ;;
23881   *)
23882   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23883 for as_dir in $PATH
23884 do
23885   IFS=$as_save_IFS
23886   test -z "$as_dir" && as_dir=.
23887     for ac_exec_ext in '' $ac_executable_extensions; do
23888   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23889     ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
23890     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23891     break 2
23892   fi
23893 done
23894   done
23895 IFS=$as_save_IFS
23896 
23897   ;;
23898 esac
23899 fi
23900 SETFILE=$ac_cv_path_SETFILE
23901 if test -n "$SETFILE"; then
23902   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
23903 $as_echo "$SETFILE" >&6; }
23904 else
23905   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23906 $as_echo "no" >&6; }
23907 fi
23908 
23909 
23910   test -n "$SETFILE" && break
23911 done
23912 
23913     else
23914       # If it succeeded, then it was overridden by the user. We will use it
23915       # for the tool.
23916 
23917       # First remove it from the list of overridden variables, so we can test
23918       # for unknown variables in the end.
23919       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
23920 
23921       # Check if we try to supply an empty value
23922       if test "x$SETFILE" = x; then
23923         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool SETFILE= (no value)" >&5
23924 $as_echo "$as_me: Setting user supplied tool SETFILE= (no value)" >&6;}
23925         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SETFILE" >&5
23926 $as_echo_n "checking for SETFILE... " >&6; }
23927         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
23928 $as_echo "disabled" >&6; }
23929       else
23930         # Check if the provided tool contains a complete path.
23931         tool_specified="$SETFILE"
23932         tool_basename="${tool_specified##*/}"
23933         if test "x$tool_basename" = "x$tool_specified"; then
23934           # A command without a complete path is provided, search $PATH.
23935           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SETFILE=$tool_basename" >&5
23936 $as_echo "$as_me: Will search for user supplied tool SETFILE=$tool_basename" >&6;}
23937           # Extract the first word of "$tool_basename", so it can be a program name with args.
23938 set dummy $tool_basename; ac_word=$2
23939 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23940 $as_echo_n "checking for $ac_word... " >&6; }
23941 if ${ac_cv_path_SETFILE+:} false; then :
23942   $as_echo_n "(cached) " >&6
23943 else
23944   case $SETFILE in
23945   [\\/]* | ?:[\\/]*)
23946   ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
23947   ;;
23948   *)
23949   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23950 for as_dir in $PATH
23951 do
23952   IFS=$as_save_IFS
23953   test -z "$as_dir" && as_dir=.
23954     for ac_exec_ext in '' $ac_executable_extensions; do
23955   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23956     ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
23957     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23958     break 2
23959   fi
23960 done
23961   done
23962 IFS=$as_save_IFS
23963 
23964   ;;
23965 esac
23966 fi
23967 SETFILE=$ac_cv_path_SETFILE
23968 if test -n "$SETFILE"; then
23969   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
23970 $as_echo "$SETFILE" >&6; }
23971 else
23972   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23973 $as_echo "no" >&6; }
23974 fi
23975 
23976 
23977           if test "x$SETFILE" = x; then
23978             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
23979           fi
23980         else
23981           # Otherwise we believe it is a complete path. Use it as it is.
23982           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SETFILE=$tool_specified" >&5
23983 $as_echo "$as_me: Will use user supplied tool SETFILE=$tool_specified" >&6;}
23984           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SETFILE" >&5
23985 $as_echo_n "checking for SETFILE... " >&6; }
23986           if test ! -x "$tool_specified"; then
23987             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
23988 $as_echo "not found" >&6; }
23989             as_fn_error $? "User supplied tool SETFILE=$tool_specified does not exist or is not executable" "$LINENO" 5
23990           fi
23991           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
23992 $as_echo "$tool_specified" >&6; }
23993         fi
23994       fi
23995     fi
23996 
23997   fi
23998 
23999 
24000 
24001   if test "x$SETFILE" = x; then
24002     as_fn_error $? "Could not find required tool for SETFILE" "$LINENO" 5
24003   fi
24004 
24005 
24006   fi
24007 
24008 
24009   # Test if bash supports pipefail.
24010   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if bash supports pipefail" >&5
24011 $as_echo_n "checking if bash supports pipefail... " >&6; }
24012   if ${BASH} -c 'set -o pipefail'; then
24013     BASH_ARGS="$BASH_ARGS -o pipefail"
24014     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
24015 $as_echo "yes" >&6; }
24016   else
24017     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
24018 $as_echo "no" >&6; }
24019   fi
24020 
24021   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if bash supports errexit (-e)" >&5
24022 $as_echo_n "checking if bash supports errexit (-e)... " >&6; }
24023   if ${BASH} -e -c 'true'; then
24024     BASH_ARGS="$BASH_ARGS -e"
24025     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
24026 $as_echo "yes" >&6; }
24027   else
24028     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
24029 $as_echo "no" >&6; }
24030   fi
24031 
24032 
24033 
24034 
24035 # Check if pkg-config is available.
24036 
24037 
24038 if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then
24039         if test -n "$ac_tool_prefix"; then
24040   # Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args.
24041 set dummy ${ac_tool_prefix}pkg-config; ac_word=$2
24042 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
24043 $as_echo_n "checking for $ac_word... " >&6; }
24044 if ${ac_cv_path_PKG_CONFIG+:} false; then :
24045   $as_echo_n "(cached) " >&6
24046 else
24047   case $PKG_CONFIG in
24048   [\\/]* | ?:[\\/]*)
24049   ac_cv_path_PKG_CONFIG="$PKG_CONFIG" # Let the user override the test with a path.
24050   ;;
24051   *)
24052   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
24053 for as_dir in $PATH
24054 do
24055   IFS=$as_save_IFS
24056   test -z "$as_dir" && as_dir=.
24057     for ac_exec_ext in '' $ac_executable_extensions; do
24058   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
24059     ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
24060     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
24061     break 2
24062   fi
24063 done
24064   done
24065 IFS=$as_save_IFS
24066 
24067   ;;
24068 esac
24069 fi
24070 PKG_CONFIG=$ac_cv_path_PKG_CONFIG
24071 if test -n "$PKG_CONFIG"; then
24072   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
24073 $as_echo "$PKG_CONFIG" >&6; }
24074 else
24075   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
24076 $as_echo "no" >&6; }
24077 fi
24078 
24079 
24080 fi
24081 if test -z "$ac_cv_path_PKG_CONFIG"; then
24082   ac_pt_PKG_CONFIG=$PKG_CONFIG
24083   # Extract the first word of "pkg-config", so it can be a program name with args.
24084 set dummy pkg-config; ac_word=$2
24085 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
24086 $as_echo_n "checking for $ac_word... " >&6; }
24087 if ${ac_cv_path_ac_pt_PKG_CONFIG+:} false; then :
24088   $as_echo_n "(cached) " >&6
24089 else
24090   case $ac_pt_PKG_CONFIG in
24091   [\\/]* | ?:[\\/]*)
24092   ac_cv_path_ac_pt_PKG_CONFIG="$ac_pt_PKG_CONFIG" # Let the user override the test with a path.
24093   ;;
24094   *)
24095   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
24096 for as_dir in $PATH
24097 do
24098   IFS=$as_save_IFS
24099   test -z "$as_dir" && as_dir=.
24100     for ac_exec_ext in '' $ac_executable_extensions; do
24101   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
24102     ac_cv_path_ac_pt_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
24103     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
24104     break 2
24105   fi
24106 done
24107   done
24108 IFS=$as_save_IFS
24109 
24110   ;;
24111 esac
24112 fi
24113 ac_pt_PKG_CONFIG=$ac_cv_path_ac_pt_PKG_CONFIG
24114 if test -n "$ac_pt_PKG_CONFIG"; then
24115   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_pt_PKG_CONFIG" >&5
24116 $as_echo "$ac_pt_PKG_CONFIG" >&6; }
24117 else
24118   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
24119 $as_echo "no" >&6; }
24120 fi
24121 
24122   if test "x$ac_pt_PKG_CONFIG" = x; then
24123     PKG_CONFIG=""
24124   else
24125     case $cross_compiling:$ac_tool_warned in
24126 yes:)
24127 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
24128 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
24129 ac_tool_warned=yes ;;
24130 esac
24131     PKG_CONFIG=$ac_pt_PKG_CONFIG
24132   fi
24133 else
24134   PKG_CONFIG="$ac_cv_path_PKG_CONFIG"
24135 fi
24136 
24137 fi
24138 if test -n "$PKG_CONFIG"; then
24139         _pkg_min_version=0.9.0
24140         { $as_echo "$as_me:${as_lineno-$LINENO}: checking pkg-config is at least version $_pkg_min_version" >&5
24141 $as_echo_n "checking pkg-config is at least version $_pkg_min_version... " >&6; }
24142         if $PKG_CONFIG --atleast-pkgconfig-version $_pkg_min_version; then
24143                 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
24144 $as_echo "yes" >&6; }
24145         else
24146                 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
24147 $as_echo "no" >&6; }
24148                 PKG_CONFIG=""
24149         fi
24150 
24151 fi
24152 
24153 # After basic tools have been setup, we can check build os specific details.
24154 
24155   ###############################################################################
24156 
24157   # Note that this is the build platform OS version!
24158 
24159   OS_VERSION="`uname -r | ${SED} 's!\.! !g' | ${SED} 's!-! !g'`"
24160   OS_VERSION_MAJOR="`${ECHO} ${OS_VERSION} | ${CUT} -f 1 -d ' '`"
24161   OS_VERSION_MINOR="`${ECHO} ${OS_VERSION} | ${CUT} -f 2 -d ' '`"
24162   OS_VERSION_MICRO="`${ECHO} ${OS_VERSION} | ${CUT} -f 3 -d ' '`"
24163 
24164 
24165 
24166 
24167 
24168 # Misc basic settings
24169 
24170 
24171 # Check whether --with-default-make-target was given.
24172 if test "${with_default_make_target+set}" = set; then :
24173   withval=$with_default_make_target;
24174 fi
24175 
24176   if test "x$with_default_make_target" = "x" \
24177       || test "x$with_default_make_target" = "xyes"; then
24178     DEFAULT_MAKE_TARGET="exploded-image"
24179   elif test "x$with_default_make_target" = "xno"; then
24180     as_fn_error $? "--without-default-make-target is not a valid option" "$LINENO" 5
24181   else
24182     DEFAULT_MAKE_TARGET="$with_default_make_target"
24183   fi
24184 
24185 
24186 
24187 
24188 ###############################################################################
24189 #
24190 # Determine OpenJDK variants, options and version numbers.
24191 #
24192 ###############################################################################
24193 
24194 # We need build & target for this.
24195 
24196   # Should we build a JDK/JVM with headful support (ie a graphical ui)?
24197   # We always build headless support.
24198   { $as_echo "$as_me:${as_lineno-$LINENO}: checking headful support" >&5
24199 $as_echo_n "checking headful support... " >&6; }
24200   # Check whether --enable-headful was given.
24201 if test "${enable_headful+set}" = set; then :
24202   enableval=$enable_headful; SUPPORT_HEADFUL=${enable_headful}
24203 else
24204   SUPPORT_HEADFUL=yes
24205 fi
24206 
24207 
24208   SUPPORT_HEADLESS=yes
24209   BUILD_HEADLESS="BUILD_HEADLESS:=true"
24210 
24211   if test "x$SUPPORT_HEADFUL" = xyes; then
24212     # We are building both headful and headless.
24213     headful_msg="include support for both headful and headless"
24214   fi
24215 
24216   if test "x$SUPPORT_HEADFUL" = xno; then
24217     # Thus we are building headless only.
24218     BUILD_HEADLESS="BUILD_HEADLESS:=true"
24219     headful_msg="headless only"
24220   fi
24221 
24222   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $headful_msg" >&5
24223 $as_echo "$headful_msg" >&6; }
24224 
24225 
24226 
24227 
24228 
24229   # Choose cacerts source file
24230 
24231 # Check whether --with-cacerts-file was given.
24232 if test "${with_cacerts_file+set}" = set; then :
24233   withval=$with_cacerts_file;
24234 fi
24235 
24236   if test "x$with_cacerts_file" != x; then
24237     CACERTS_FILE=$with_cacerts_file
24238   fi
24239 
24240 
24241   # Enable or disable unlimited crypto
24242   # Check whether --enable-unlimited-crypto was given.
24243 if test "${enable_unlimited_crypto+set}" = set; then :
24244   enableval=$enable_unlimited_crypto;
24245 else
24246   enable_unlimited_crypto=no
24247 fi
24248 
24249   if test "x$enable_unlimited_crypto" = "xyes"; then
24250     UNLIMITED_CRYPTO=true
24251   else
24252     UNLIMITED_CRYPTO=false
24253   fi
24254 
24255 
24256   # Should we build the serviceability agent (SA)?
24257   INCLUDE_SA=true
24258   if   [[ " $JVM_VARIANTS " =~ " zero " ]]   ||   [[ " $JVM_VARIANTS " =~ " zeroshark " ]]  ; then
24259     INCLUDE_SA=false
24260   fi
24261   if test "x$OPENJDK_TARGET_OS" = xaix ; then
24262     INCLUDE_SA=false
24263   fi
24264 
24265 
24266   # Compress jars
24267   COMPRESS_JARS=false
24268 
24269 
24270 
24271   # Setup default copyright year. Mostly overridden when building close to a new year.
24272 
24273 # Check whether --with-copyright-year was given.
24274 if test "${with_copyright_year+set}" = set; then :
24275   withval=$with_copyright_year;
24276 fi
24277 
24278   if test "x$with_copyright_year" = xyes; then
24279     as_fn_error $? "Copyright year must have a value" "$LINENO" 5
24280   elif test "x$with_copyright_year" != x; then
24281     COPYRIGHT_YEAR="$with_copyright_year"
24282   else
24283     COPYRIGHT_YEAR=`$DATE +'%Y'`
24284   fi
24285 
24286 
24287 
24288   # Check whether --enable-keep-packaged-modules was given.
24289 if test "${enable_keep_packaged_modules+set}" = set; then :
24290   enableval=$enable_keep_packaged_modules;
24291 fi
24292 
24293 
24294   if test "x$enable_keep_packaged_modules" = "xyes"; then
24295     { $as_echo "$as_me:${as_lineno-$LINENO}: checking if packaged modules are kept" >&5
24296 $as_echo_n "checking if packaged modules are kept... " >&6; }
24297     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
24298 $as_echo "yes" >&6; }
24299     JLINK_KEEP_PACKAGED_MODULES=true
24300   elif test "x$enable_keep_packaged_modules" = "xno"; then
24301     { $as_echo "$as_me:${as_lineno-$LINENO}: checking if packaged modules are kept" >&5
24302 $as_echo_n "checking if packaged modules are kept... " >&6; }
24303     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
24304 $as_echo "no" >&6; }
24305     JLINK_KEEP_PACKAGED_MODULES=false
24306   elif test "x$enable_keep_packaged_modules" = "x"; then
24307     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes (default)" >&5
24308 $as_echo "yes (default)" >&6; }
24309     JLINK_KEEP_PACKAGED_MODULES=true
24310   else
24311     as_fn_error $? "--enable-keep-packaged-modules accepts no argument" "$LINENO" 5
24312   fi
24313 
24314 
24315 
24316 
24317   # Warn user that old version arguments are deprecated.
24318 
24319 
24320 # Check whether --with-milestone was given.
24321 if test "${with_milestone+set}" = set; then :
24322   withval=$with_milestone; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-milestone is deprecated and will be ignored." >&5
24323 $as_echo "$as_me: WARNING: Option --with-milestone is deprecated and will be ignored." >&2;}
24324 fi
24325 
24326 
24327 
24328 
24329 # Check whether --with-update-version was given.
24330 if test "${with_update_version+set}" = set; then :
24331   withval=$with_update_version; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-update-version is deprecated and will be ignored." >&5
24332 $as_echo "$as_me: WARNING: Option --with-update-version is deprecated and will be ignored." >&2;}
24333 fi
24334 
24335 
24336 
24337 
24338 # Check whether --with-user-release-suffix was given.
24339 if test "${with_user_release_suffix+set}" = set; then :
24340   withval=$with_user_release_suffix; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-user-release-suffix is deprecated and will be ignored." >&5
24341 $as_echo "$as_me: WARNING: Option --with-user-release-suffix is deprecated and will be ignored." >&2;}
24342 fi
24343 
24344 
24345 
24346 
24347 # Check whether --with-build-number was given.
24348 if test "${with_build_number+set}" = set; then :
24349   withval=$with_build_number; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-build-number is deprecated and will be ignored." >&5
24350 $as_echo "$as_me: WARNING: Option --with-build-number is deprecated and will be ignored." >&2;}
24351 fi
24352 
24353 
24354 
24355   # Source the version numbers file
24356   . $AUTOCONF_DIR/version-numbers
24357 
24358   # Some non-version number information is set in that file
24359 
24360 
24361 
24362 
24363 
24364 
24365 
24366 
24367 
24368   # Override version from arguments
24369 
24370   # If --with-version-string is set, process it first. It is possible to
24371   # override parts with more specific flags, since these are processed later.
24372 
24373 # Check whether --with-version-string was given.
24374 if test "${with_version_string+set}" = set; then :
24375   withval=$with_version_string;
24376 fi
24377 
24378   if test "x$with_version_string" = xyes; then
24379     as_fn_error $? "--with-version-string must have a value" "$LINENO" 5
24380   elif test "x$with_version_string" != x; then
24381     # Additional [] needed to keep m4 from mangling shell constructs.
24382     if  [[ $with_version_string =~ ^([0-9]+)(\.([0-9]+))?(\.([0-9]+))?(\.([0-9]+))?(-([a-zA-Z]+))?((\+)([0-9]+)?(-([-a-zA-Z0-9.]+))?)?$ ]] ; then
24383       VERSION_MAJOR=${BASH_REMATCH[1]}
24384       VERSION_MINOR=${BASH_REMATCH[3]}
24385       VERSION_SECURITY=${BASH_REMATCH[5]}
24386       VERSION_PATCH=${BASH_REMATCH[7]}
24387       VERSION_PRE=${BASH_REMATCH[9]}
24388       version_plus_separator=${BASH_REMATCH[11]}
24389       VERSION_BUILD=${BASH_REMATCH[12]}
24390       VERSION_OPT=${BASH_REMATCH[14]}
24391       # Unspecified numerical fields are interpreted as 0.
24392       if test "x$VERSION_MINOR" = x; then
24393         VERSION_MINOR=0
24394       fi
24395       if test "x$VERSION_SECURITY" = x; then
24396         VERSION_SECURITY=0
24397       fi
24398       if test "x$VERSION_PATCH" = x; then
24399         VERSION_PATCH=0
24400       fi
24401       if test "x$version_plus_separator" != x \
24402           && test "x$VERSION_BUILD$VERSION_OPT" = x; then
24403         as_fn_error $? "Version string contains + but both 'BUILD' and 'OPT' are missing" "$LINENO" 5
24404       fi
24405       # Stop the version part process from setting default values.
24406       # We still allow them to explicitely override though.
24407       NO_DEFAULT_VERSION_PARTS=true
24408     else
24409       as_fn_error $? "--with-version-string fails to parse as a valid version string: $with_version_string" "$LINENO" 5
24410     fi
24411   fi
24412 
24413 
24414 # Check whether --with-version-pre was given.
24415 if test "${with_version_pre+set}" = set; then :
24416   withval=$with_version_pre; with_version_pre_present=true
24417 else
24418   with_version_pre_present=false
24419 fi
24420 
24421 
24422   if test "x$with_version_pre_present" = xtrue; then
24423     if test "x$with_version_pre" = xyes; then
24424       as_fn_error $? "--with-version-pre must have a value" "$LINENO" 5
24425     elif test "x$with_version_pre" = xno; then
24426       # Interpret --without-* as empty string instead of the literal "no"
24427       VERSION_PRE=
24428     else
24429       # Only [a-zA-Z] is allowed in the VERSION_PRE. Outer [ ] to quote m4.
24430        VERSION_PRE=`$ECHO "$with_version_pre" | $TR -c -d '[a-z][A-Z]'`
24431       if test "x$VERSION_PRE" != "x$with_version_pre"; then
24432         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: --with-version-pre value has been sanitized from '$with_version_pre' to '$VERSION_PRE'" >&5
24433 $as_echo "$as_me: WARNING: --with-version-pre value has been sanitized from '$with_version_pre' to '$VERSION_PRE'" >&2;}
24434       fi
24435     fi
24436   else
24437     if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
24438       # Default is to use "internal" as pre
24439       VERSION_PRE="internal"
24440     fi
24441   fi
24442 
24443 
24444 # Check whether --with-version-opt was given.
24445 if test "${with_version_opt+set}" = set; then :
24446   withval=$with_version_opt; with_version_opt_present=true
24447 else
24448   with_version_opt_present=false
24449 fi
24450 
24451 
24452   if test "x$with_version_opt_present" = xtrue; then
24453     if test "x$with_version_opt" = xyes; then
24454       as_fn_error $? "--with-version-opt must have a value" "$LINENO" 5
24455     elif test "x$with_version_opt" = xno; then
24456       # Interpret --without-* as empty string instead of the literal "no"
24457       VERSION_OPT=
24458     else
24459       # Only [-.a-zA-Z0-9] is allowed in the VERSION_OPT. Outer [ ] to quote m4.
24460        VERSION_OPT=`$ECHO "$with_version_opt" | $TR -c -d '[a-z][A-Z][0-9].-'`
24461       if test "x$VERSION_OPT" != "x$with_version_opt"; then
24462         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: --with-version-opt value has been sanitized from '$with_version_opt' to '$VERSION_OPT'" >&5
24463 $as_echo "$as_me: WARNING: --with-version-opt value has been sanitized from '$with_version_opt' to '$VERSION_OPT'" >&2;}
24464       fi
24465     fi
24466   else
24467     if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
24468       # Default is to calculate a string like this <timestamp>.<username>.<base dir name>
24469       timestamp=`$DATE '+%Y-%m-%d-%H%M%S'`
24470       # Outer [ ] to quote m4.
24471        basedirname=`$BASENAME "$TOPDIR" | $TR -d -c '[a-z][A-Z][0-9].-'`
24472       VERSION_OPT="$timestamp.$USERNAME.$basedirname"
24473     fi
24474   fi
24475 
24476 
24477 # Check whether --with-version-build was given.
24478 if test "${with_version_build+set}" = set; then :
24479   withval=$with_version_build; with_version_build_present=true
24480 else
24481   with_version_build_present=false
24482 fi
24483 
24484 
24485   if test "x$with_version_build_present" = xtrue; then
24486     if test "x$with_version_build" = xyes; then
24487       as_fn_error $? "--with-version-build must have a value" "$LINENO" 5
24488     elif test "x$with_version_build" = xno; then
24489       # Interpret --without-* as empty string instead of the literal "no"
24490       VERSION_BUILD=
24491     elif test "x$with_version_build" = x; then
24492       VERSION_BUILD=
24493     else
24494 
24495   # Additional [] needed to keep m4 from mangling shell constructs.
24496   if  ! [[ "$with_version_build" =~ ^0*([1-9][0-9]*)|(0)$ ]]  ; then
24497     as_fn_error $? "\"$with_version_build\" is not a valid numerical value for VERSION_BUILD" "$LINENO" 5
24498   fi
24499   # Extract the version number without leading zeros.
24500   cleaned_value=${BASH_REMATCH[1]}
24501   if test "x$cleaned_value" = x; then
24502     # Special case for zero
24503     cleaned_value=${BASH_REMATCH[2]}
24504   fi
24505 
24506   if test $cleaned_value -gt 255; then
24507     as_fn_error $? "VERSION_BUILD is given as $with_version_build. This is greater than 255 which is not allowed." "$LINENO" 5
24508   fi
24509   if test "x$cleaned_value" != "x$with_version_build"; then
24510     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Value for VERSION_BUILD has been sanitized from '$with_version_build' to '$cleaned_value'" >&5
24511 $as_echo "$as_me: WARNING: Value for VERSION_BUILD has been sanitized from '$with_version_build' to '$cleaned_value'" >&2;}
24512   fi
24513   VERSION_BUILD=$cleaned_value
24514 
24515     fi
24516   else
24517     if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
24518       # Default is to not have a build number.
24519       VERSION_BUILD=""
24520       # FIXME: Until all code can cope with an empty VERSION_BUILD, set it to 0.
24521       VERSION_BUILD=0
24522     fi
24523   fi
24524 
24525 
24526 # Check whether --with-version-major was given.
24527 if test "${with_version_major+set}" = set; then :
24528   withval=$with_version_major; with_version_major_present=true
24529 else
24530   with_version_major_present=false
24531 fi
24532 
24533 
24534   if test "x$with_version_major_present" = xtrue; then
24535     if test "x$with_version_major" = xyes; then
24536       as_fn_error $? "--with-version-major must have a value" "$LINENO" 5
24537     else
24538 
24539   # Additional [] needed to keep m4 from mangling shell constructs.
24540   if  ! [[ "$with_version_major" =~ ^0*([1-9][0-9]*)|(0)$ ]]  ; then
24541     as_fn_error $? "\"$with_version_major\" is not a valid numerical value for VERSION_MAJOR" "$LINENO" 5
24542   fi
24543   # Extract the version number without leading zeros.
24544   cleaned_value=${BASH_REMATCH[1]}
24545   if test "x$cleaned_value" = x; then
24546     # Special case for zero
24547     cleaned_value=${BASH_REMATCH[2]}
24548   fi
24549 
24550   if test $cleaned_value -gt 255; then
24551     as_fn_error $? "VERSION_MAJOR is given as $with_version_major. This is greater than 255 which is not allowed." "$LINENO" 5
24552   fi
24553   if test "x$cleaned_value" != "x$with_version_major"; then
24554     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Value for VERSION_MAJOR has been sanitized from '$with_version_major' to '$cleaned_value'" >&5
24555 $as_echo "$as_me: WARNING: Value for VERSION_MAJOR has been sanitized from '$with_version_major' to '$cleaned_value'" >&2;}
24556   fi
24557   VERSION_MAJOR=$cleaned_value
24558 
24559     fi
24560   else
24561     if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
24562       # Default is to get value from version-numbers
24563       VERSION_MAJOR="$DEFAULT_VERSION_MAJOR"
24564     fi
24565   fi
24566 
24567 
24568 # Check whether --with-version-minor was given.
24569 if test "${with_version_minor+set}" = set; then :
24570   withval=$with_version_minor; with_version_minor_present=true
24571 else
24572   with_version_minor_present=false
24573 fi
24574 
24575 
24576   if test "x$with_version_minor_present" = xtrue; then
24577     if test "x$with_version_minor" = xyes; then
24578       as_fn_error $? "--with-version-minor must have a value" "$LINENO" 5
24579     elif test "x$with_version_minor" = xno; then
24580       # Interpret --without-* as empty string (i.e. 0) instead of the literal "no"
24581       VERSION_MINOR=0
24582     elif test "x$with_version_minor" = x; then
24583       VERSION_MINOR=0
24584     else
24585 
24586   # Additional [] needed to keep m4 from mangling shell constructs.
24587   if  ! [[ "$with_version_minor" =~ ^0*([1-9][0-9]*)|(0)$ ]]  ; then
24588     as_fn_error $? "\"$with_version_minor\" is not a valid numerical value for VERSION_MINOR" "$LINENO" 5
24589   fi
24590   # Extract the version number without leading zeros.
24591   cleaned_value=${BASH_REMATCH[1]}
24592   if test "x$cleaned_value" = x; then
24593     # Special case for zero
24594     cleaned_value=${BASH_REMATCH[2]}
24595   fi
24596 
24597   if test $cleaned_value -gt 255; then
24598     as_fn_error $? "VERSION_MINOR is given as $with_version_minor. This is greater than 255 which is not allowed." "$LINENO" 5
24599   fi
24600   if test "x$cleaned_value" != "x$with_version_minor"; then
24601     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Value for VERSION_MINOR has been sanitized from '$with_version_minor' to '$cleaned_value'" >&5
24602 $as_echo "$as_me: WARNING: Value for VERSION_MINOR has been sanitized from '$with_version_minor' to '$cleaned_value'" >&2;}
24603   fi
24604   VERSION_MINOR=$cleaned_value
24605 
24606     fi
24607   else
24608     if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
24609       # Default is 0, if unspecified
24610       VERSION_MINOR=0
24611     fi
24612   fi
24613 
24614 
24615 # Check whether --with-version-security was given.
24616 if test "${with_version_security+set}" = set; then :
24617   withval=$with_version_security; with_version_security_present=true
24618 else
24619   with_version_security_present=false
24620 fi
24621 
24622 
24623   if test "x$with_version_security_present" = xtrue; then
24624     if test "x$with_version_security" = xyes; then
24625       as_fn_error $? "--with-version-security must have a value" "$LINENO" 5
24626     elif test "x$with_version_security" = xno; then
24627       # Interpret --without-* as empty string (i.e. 0) instead of the literal "no"
24628       VERSION_SECURITY=0
24629     elif test "x$with_version_security" = x; then
24630       VERSION_SECURITY=0
24631     else
24632 
24633   # Additional [] needed to keep m4 from mangling shell constructs.
24634   if  ! [[ "$with_version_security" =~ ^0*([1-9][0-9]*)|(0)$ ]]  ; then
24635     as_fn_error $? "\"$with_version_security\" is not a valid numerical value for VERSION_SECURITY" "$LINENO" 5
24636   fi
24637   # Extract the version number without leading zeros.
24638   cleaned_value=${BASH_REMATCH[1]}
24639   if test "x$cleaned_value" = x; then
24640     # Special case for zero
24641     cleaned_value=${BASH_REMATCH[2]}
24642   fi
24643 
24644   if test $cleaned_value -gt 255; then
24645     as_fn_error $? "VERSION_SECURITY is given as $with_version_security. This is greater than 255 which is not allowed." "$LINENO" 5
24646   fi
24647   if test "x$cleaned_value" != "x$with_version_security"; then
24648     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Value for VERSION_SECURITY has been sanitized from '$with_version_security' to '$cleaned_value'" >&5
24649 $as_echo "$as_me: WARNING: Value for VERSION_SECURITY has been sanitized from '$with_version_security' to '$cleaned_value'" >&2;}
24650   fi
24651   VERSION_SECURITY=$cleaned_value
24652 
24653     fi
24654   else
24655     if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
24656       # Default is 0, if unspecified
24657       VERSION_SECURITY=0
24658     fi
24659   fi
24660 
24661 
24662 # Check whether --with-version-patch was given.
24663 if test "${with_version_patch+set}" = set; then :
24664   withval=$with_version_patch; with_version_patch_present=true
24665 else
24666   with_version_patch_present=false
24667 fi
24668 
24669 
24670   if test "x$with_version_patch_present" = xtrue; then
24671     if test "x$with_version_patch" = xyes; then
24672       as_fn_error $? "--with-version-patch must have a value" "$LINENO" 5
24673     elif test "x$with_version_patch" = xno; then
24674       # Interpret --without-* as empty string (i.e. 0) instead of the literal "no"
24675       VERSION_PATCH=0
24676     elif test "x$with_version_patch" = x; then
24677       VERSION_PATCH=0
24678     else
24679 
24680   # Additional [] needed to keep m4 from mangling shell constructs.
24681   if  ! [[ "$with_version_patch" =~ ^0*([1-9][0-9]*)|(0)$ ]]  ; then
24682     as_fn_error $? "\"$with_version_patch\" is not a valid numerical value for VERSION_PATCH" "$LINENO" 5
24683   fi
24684   # Extract the version number without leading zeros.
24685   cleaned_value=${BASH_REMATCH[1]}
24686   if test "x$cleaned_value" = x; then
24687     # Special case for zero
24688     cleaned_value=${BASH_REMATCH[2]}
24689   fi
24690 
24691   if test $cleaned_value -gt 255; then
24692     as_fn_error $? "VERSION_PATCH is given as $with_version_patch. This is greater than 255 which is not allowed." "$LINENO" 5
24693   fi
24694   if test "x$cleaned_value" != "x$with_version_patch"; then
24695     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Value for VERSION_PATCH has been sanitized from '$with_version_patch' to '$cleaned_value'" >&5
24696 $as_echo "$as_me: WARNING: Value for VERSION_PATCH has been sanitized from '$with_version_patch' to '$cleaned_value'" >&2;}
24697   fi
24698   VERSION_PATCH=$cleaned_value
24699 
24700     fi
24701   else
24702     if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
24703       # Default is 0, if unspecified
24704       VERSION_PATCH=0
24705     fi
24706   fi
24707 
24708   # Calculate derived version properties
24709 
24710   # Set VERSION_IS_GA based on if VERSION_PRE has a value
24711   if test "x$VERSION_PRE" = x; then
24712     VERSION_IS_GA=true
24713   else
24714     VERSION_IS_GA=false
24715   fi
24716 
24717   # VERSION_NUMBER but always with exactly 4 positions, with 0 for empty positions.
24718   VERSION_NUMBER_FOUR_POSITIONS=$VERSION_MAJOR.$VERSION_MINOR.$VERSION_SECURITY.$VERSION_PATCH
24719 
24720   stripped_version_number=$VERSION_NUMBER_FOUR_POSITIONS
24721   # Strip trailing zeroes from stripped_version_number
24722   for i in 1 2 3 ; do stripped_version_number=${stripped_version_number%.0} ; done
24723   VERSION_NUMBER=$stripped_version_number
24724 
24725   # The complete version string, with additional build information
24726   if test "x$VERSION_BUILD$VERSION_OPT" = x; then
24727     VERSION_STRING=$VERSION_NUMBER${VERSION_PRE:+-$VERSION_PRE}
24728   else
24729     # If either build or opt is set, we need a + separator
24730     VERSION_STRING=$VERSION_NUMBER${VERSION_PRE:+-$VERSION_PRE}+$VERSION_BUILD${VERSION_OPT:+-$VERSION_OPT}
24731   fi
24732 
24733   # The short version string, just VERSION_NUMBER and PRE, if present.
24734   VERSION_SHORT=$VERSION_NUMBER${VERSION_PRE:+-$VERSION_PRE}
24735 
24736   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for version string" >&5
24737 $as_echo_n "checking for version string... " >&6; }
24738   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $VERSION_STRING" >&5
24739 $as_echo "$VERSION_STRING" >&6; }
24740 
24741 
24742 
24743 
24744 
24745 
24746 
24747 
24748 
24749 
24750 
24751 
24752 
24753 
24754 
24755 ###############################################################################
24756 #
24757 # Setup BootJDK, used to bootstrap the build.
24758 #
24759 ###############################################################################
24760 
24761 
24762   BOOT_JDK_FOUND=no
24763 
24764 # Check whether --with-boot-jdk was given.
24765 if test "${with_boot_jdk+set}" = set; then :
24766   withval=$with_boot_jdk;
24767 fi
24768 
24769 
24770   # We look for the Boot JDK through various means, going from more certain to
24771   # more of a guess-work. After each test, BOOT_JDK_FOUND is set to "yes" if
24772   # we detected something (if so, the path to the jdk is in BOOT_JDK). But we
24773   # must check if this is indeed valid; otherwise we'll continue looking.
24774 
24775   # Test: Is bootjdk explicitely set by command line arguments?
24776 
24777   if test "x$BOOT_JDK_FOUND" = xno; then
24778     # Now execute the test
24779 
24780   if test "x$with_boot_jdk" != x; then
24781     BOOT_JDK=$with_boot_jdk
24782     BOOT_JDK_FOUND=maybe
24783     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using configure arguments" >&5
24784 $as_echo "$as_me: Found potential Boot JDK using configure arguments" >&6;}
24785   fi
24786 
24787 
24788     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24789     if test "x$BOOT_JDK_FOUND" = xmaybe; then
24790       # Do we have a bin/java?
24791       if test ! -x "$BOOT_JDK/bin/java"; then
24792         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24793 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24794         BOOT_JDK_FOUND=no
24795       else
24796         # Do we have a bin/javac?
24797         if test ! -x "$BOOT_JDK/bin/javac"; then
24798           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24799 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24800           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24801 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24802           BOOT_JDK_FOUND=no
24803         else
24804           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24805           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
24806 
24807           # Extra M4 quote needed to protect [] in grep expression.
24808           FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
24809           if test "x$FOUND_CORRECT_VERSION" = x; then
24810             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24811 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24812             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
24813 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
24814             BOOT_JDK_FOUND=no
24815           else
24816             # We're done! :-)
24817             BOOT_JDK_FOUND=yes
24818 
24819   # Only process if variable expands to non-empty
24820 
24821   if test "x$BOOT_JDK" != x; then
24822     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24823 
24824   # Input might be given as Windows format, start by converting to
24825   # unix format.
24826   path="$BOOT_JDK"
24827   new_path=`$CYGPATH -u "$path"`
24828 
24829   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24830   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24831   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24832   # "foo.exe" is OK but "foo" is an error.
24833   #
24834   # This test is therefore slightly more accurate than "test -f" to check for file precense.
24835   # It is also a way to make sure we got the proper file name for the real test later on.
24836   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24837   if test "x$test_shortpath" = x; then
24838     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24839 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24840     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24841   fi
24842 
24843   # Call helper function which possibly converts this using DOS-style short mode.
24844   # If so, the updated path is stored in $new_path.
24845 
24846   input_path="$new_path"
24847   # Check if we need to convert this using DOS-style short mode. If the path
24848   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24849   # take no chances and rewrite it.
24850   # Note: m4 eats our [], so we need to use [ and ] instead.
24851   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24852   if test "x$has_forbidden_chars" != x; then
24853     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24854     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24855     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24856     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24857       # Going to short mode and back again did indeed matter. Since short mode is
24858       # case insensitive, let's make it lowercase to improve readability.
24859       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24860       # Now convert it back to Unix-style (cygpath)
24861       input_path=`$CYGPATH -u "$shortmode_path"`
24862       new_path="$input_path"
24863     fi
24864   fi
24865 
24866   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24867   if test "x$test_cygdrive_prefix" = x; then
24868     # As a simple fix, exclude /usr/bin since it's not a real path.
24869     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24870       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24871       # a path prefixed by /cygdrive for fixpath to work.
24872       new_path="$CYGWIN_ROOT_PATH$input_path"
24873     fi
24874   fi
24875 
24876 
24877   if test "x$path" != "x$new_path"; then
24878     BOOT_JDK="$new_path"
24879     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24880 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24881   fi
24882 
24883     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24884 
24885   path="$BOOT_JDK"
24886   has_colon=`$ECHO $path | $GREP ^.:`
24887   new_path="$path"
24888   if test "x$has_colon" = x; then
24889     # Not in mixed or Windows style, start by that.
24890     new_path=`cmd //c echo $path`
24891   fi
24892 
24893 
24894   input_path="$new_path"
24895   # Check if we need to convert this using DOS-style short mode. If the path
24896   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24897   # take no chances and rewrite it.
24898   # Note: m4 eats our [], so we need to use [ and ] instead.
24899   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24900   if test "x$has_forbidden_chars" != x; then
24901     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24902     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24903   fi
24904 
24905 
24906   windows_path="$new_path"
24907   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24908     unix_path=`$CYGPATH -u "$windows_path"`
24909     new_path="$unix_path"
24910   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24911     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24912     new_path="$unix_path"
24913   fi
24914 
24915   if test "x$path" != "x$new_path"; then
24916     BOOT_JDK="$new_path"
24917     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24918 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24919   fi
24920 
24921   # Save the first 10 bytes of this path to the storage, so fixpath can work.
24922   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24923 
24924     else
24925       # We're on a unix platform. Hooray! :)
24926       path="$BOOT_JDK"
24927       has_space=`$ECHO "$path" | $GREP " "`
24928       if test "x$has_space" != x; then
24929         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24930 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24931         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24932       fi
24933 
24934       # Use eval to expand a potential ~
24935       eval path="$path"
24936       if test ! -f "$path" && test ! -d "$path"; then
24937         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24938       fi
24939 
24940       if test -d "$path"; then
24941         BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24942       else
24943         dir="`$DIRNAME "$path"`"
24944         base="`$BASENAME "$path"`"
24945         BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
24946       fi
24947     fi
24948   fi
24949 
24950             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24951 $as_echo_n "checking for Boot JDK... " >&6; }
24952             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24953 $as_echo "$BOOT_JDK" >&6; }
24954             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24955 $as_echo_n "checking Boot JDK version... " >&6; }
24956             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
24957             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24958 $as_echo "$BOOT_JDK_VERSION" >&6; }
24959           fi # end check jdk version
24960         fi # end check javac
24961       fi # end check java
24962     fi # end check boot jdk found
24963   fi
24964 
24965   if test "x$with_boot_jdk" != x && test "x$BOOT_JDK_FOUND" = xno; then
24966     # Having specified an argument which is incorrect will produce an instant failure;
24967     # we should not go on looking
24968     as_fn_error $? "The path given by --with-boot-jdk does not contain a valid Boot JDK" "$LINENO" 5
24969   fi
24970 
24971   # Test: On MacOS X, can we find a boot jdk using /usr/libexec/java_home?
24972 
24973   if test "x$BOOT_JDK_FOUND" = xno; then
24974     # Now execute the test
24975 
24976   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
24977     # First check at user selected default
24978 
24979   if test "x$BOOT_JDK_FOUND" = xno; then
24980     # Now execute the test
24981 
24982   if test -x /usr/libexec/java_home; then
24983     BOOT_JDK=`/usr/libexec/java_home `
24984     BOOT_JDK_FOUND=maybe
24985     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home " >&5
24986 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home " >&6;}
24987   fi
24988 
24989 
24990     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24991     if test "x$BOOT_JDK_FOUND" = xmaybe; then
24992       # Do we have a bin/java?
24993       if test ! -x "$BOOT_JDK/bin/java"; then
24994         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24995 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24996         BOOT_JDK_FOUND=no
24997       else
24998         # Do we have a bin/javac?
24999         if test ! -x "$BOOT_JDK/bin/javac"; then
25000           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
25001 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
25002           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
25003 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
25004           BOOT_JDK_FOUND=no
25005         else
25006           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
25007           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
25008 
25009           # Extra M4 quote needed to protect [] in grep expression.
25010           FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
25011           if test "x$FOUND_CORRECT_VERSION" = x; then
25012             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
25013 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
25014             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
25015 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
25016             BOOT_JDK_FOUND=no
25017           else
25018             # We're done! :-)
25019             BOOT_JDK_FOUND=yes
25020 
25021   # Only process if variable expands to non-empty
25022 
25023   if test "x$BOOT_JDK" != x; then
25024     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
25025 
25026   # Input might be given as Windows format, start by converting to
25027   # unix format.
25028   path="$BOOT_JDK"
25029   new_path=`$CYGPATH -u "$path"`
25030 
25031   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
25032   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
25033   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
25034   # "foo.exe" is OK but "foo" is an error.
25035   #
25036   # This test is therefore slightly more accurate than "test -f" to check for file precense.
25037   # It is also a way to make sure we got the proper file name for the real test later on.
25038   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
25039   if test "x$test_shortpath" = x; then
25040     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
25041 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
25042     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
25043   fi
25044 
25045   # Call helper function which possibly converts this using DOS-style short mode.
25046   # If so, the updated path is stored in $new_path.
25047 
25048   input_path="$new_path"
25049   # Check if we need to convert this using DOS-style short mode. If the path
25050   # contains just simple characters, use it. Otherwise (spaces, weird characters),
25051   # take no chances and rewrite it.
25052   # Note: m4 eats our [], so we need to use [ and ] instead.
25053   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
25054   if test "x$has_forbidden_chars" != x; then
25055     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
25056     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
25057     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
25058     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
25059       # Going to short mode and back again did indeed matter. Since short mode is
25060       # case insensitive, let's make it lowercase to improve readability.
25061       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
25062       # Now convert it back to Unix-style (cygpath)
25063       input_path=`$CYGPATH -u "$shortmode_path"`
25064       new_path="$input_path"
25065     fi
25066   fi
25067 
25068   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
25069   if test "x$test_cygdrive_prefix" = x; then
25070     # As a simple fix, exclude /usr/bin since it's not a real path.
25071     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
25072       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
25073       # a path prefixed by /cygdrive for fixpath to work.
25074       new_path="$CYGWIN_ROOT_PATH$input_path"
25075     fi
25076   fi
25077 
25078 
25079   if test "x$path" != "x$new_path"; then
25080     BOOT_JDK="$new_path"
25081     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
25082 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
25083   fi
25084 
25085     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
25086 
25087   path="$BOOT_JDK"
25088   has_colon=`$ECHO $path | $GREP ^.:`
25089   new_path="$path"
25090   if test "x$has_colon" = x; then
25091     # Not in mixed or Windows style, start by that.
25092     new_path=`cmd //c echo $path`
25093   fi
25094 
25095 
25096   input_path="$new_path"
25097   # Check if we need to convert this using DOS-style short mode. If the path
25098   # contains just simple characters, use it. Otherwise (spaces, weird characters),
25099   # take no chances and rewrite it.
25100   # Note: m4 eats our [], so we need to use [ and ] instead.
25101   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
25102   if test "x$has_forbidden_chars" != x; then
25103     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
25104     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
25105   fi
25106 
25107 
25108   windows_path="$new_path"
25109   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
25110     unix_path=`$CYGPATH -u "$windows_path"`
25111     new_path="$unix_path"
25112   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
25113     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
25114     new_path="$unix_path"
25115   fi
25116 
25117   if test "x$path" != "x$new_path"; then
25118     BOOT_JDK="$new_path"
25119     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
25120 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
25121   fi
25122 
25123   # Save the first 10 bytes of this path to the storage, so fixpath can work.
25124   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
25125 
25126     else
25127       # We're on a unix platform. Hooray! :)
25128       path="$BOOT_JDK"
25129       has_space=`$ECHO "$path" | $GREP " "`
25130       if test "x$has_space" != x; then
25131         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
25132 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
25133         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
25134       fi
25135 
25136       # Use eval to expand a potential ~
25137       eval path="$path"
25138       if test ! -f "$path" && test ! -d "$path"; then
25139         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
25140       fi
25141 
25142       if test -d "$path"; then
25143         BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
25144       else
25145         dir="`$DIRNAME "$path"`"
25146         base="`$BASENAME "$path"`"
25147         BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
25148       fi
25149     fi
25150   fi
25151 
25152             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
25153 $as_echo_n "checking for Boot JDK... " >&6; }
25154             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
25155 $as_echo "$BOOT_JDK" >&6; }
25156             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
25157 $as_echo_n "checking Boot JDK version... " >&6; }
25158             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
25159             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
25160 $as_echo "$BOOT_JDK_VERSION" >&6; }
25161           fi # end check jdk version
25162         fi # end check javac
25163       fi # end check java
25164     fi # end check boot jdk found
25165   fi
25166 
25167     # If that did not work out (e.g. too old), try explicit versions instead
25168 
25169   if test "x$BOOT_JDK_FOUND" = xno; then
25170     # Now execute the test
25171 
25172   if test -x /usr/libexec/java_home; then
25173     BOOT_JDK=`/usr/libexec/java_home -v 1.9`
25174     BOOT_JDK_FOUND=maybe
25175     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home -v 1.9" >&5
25176 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home -v 1.9" >&6;}
25177   fi
25178 
25179 
25180     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
25181     if test "x$BOOT_JDK_FOUND" = xmaybe; then
25182       # Do we have a bin/java?
25183       if test ! -x "$BOOT_JDK/bin/java"; then
25184         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
25185 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
25186         BOOT_JDK_FOUND=no
25187       else
25188         # Do we have a bin/javac?
25189         if test ! -x "$BOOT_JDK/bin/javac"; then
25190           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
25191 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
25192           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
25193 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
25194           BOOT_JDK_FOUND=no
25195         else
25196           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
25197           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
25198 
25199           # Extra M4 quote needed to protect [] in grep expression.
25200           FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
25201           if test "x$FOUND_CORRECT_VERSION" = x; then
25202             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
25203 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
25204             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
25205 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
25206             BOOT_JDK_FOUND=no
25207           else
25208             # We're done! :-)
25209             BOOT_JDK_FOUND=yes
25210 
25211   # Only process if variable expands to non-empty
25212 
25213   if test "x$BOOT_JDK" != x; then
25214     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
25215 
25216   # Input might be given as Windows format, start by converting to
25217   # unix format.
25218   path="$BOOT_JDK"
25219   new_path=`$CYGPATH -u "$path"`
25220 
25221   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
25222   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
25223   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
25224   # "foo.exe" is OK but "foo" is an error.
25225   #
25226   # This test is therefore slightly more accurate than "test -f" to check for file precense.
25227   # It is also a way to make sure we got the proper file name for the real test later on.
25228   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
25229   if test "x$test_shortpath" = x; then
25230     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
25231 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
25232     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
25233   fi
25234 
25235   # Call helper function which possibly converts this using DOS-style short mode.
25236   # If so, the updated path is stored in $new_path.
25237 
25238   input_path="$new_path"
25239   # Check if we need to convert this using DOS-style short mode. If the path
25240   # contains just simple characters, use it. Otherwise (spaces, weird characters),
25241   # take no chances and rewrite it.
25242   # Note: m4 eats our [], so we need to use [ and ] instead.
25243   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
25244   if test "x$has_forbidden_chars" != x; then
25245     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
25246     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
25247     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
25248     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
25249       # Going to short mode and back again did indeed matter. Since short mode is
25250       # case insensitive, let's make it lowercase to improve readability.
25251       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
25252       # Now convert it back to Unix-style (cygpath)
25253       input_path=`$CYGPATH -u "$shortmode_path"`
25254       new_path="$input_path"
25255     fi
25256   fi
25257 
25258   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
25259   if test "x$test_cygdrive_prefix" = x; then
25260     # As a simple fix, exclude /usr/bin since it's not a real path.
25261     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
25262       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
25263       # a path prefixed by /cygdrive for fixpath to work.
25264       new_path="$CYGWIN_ROOT_PATH$input_path"
25265     fi
25266   fi
25267 
25268 
25269   if test "x$path" != "x$new_path"; then
25270     BOOT_JDK="$new_path"
25271     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
25272 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
25273   fi
25274 
25275     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
25276 
25277   path="$BOOT_JDK"
25278   has_colon=`$ECHO $path | $GREP ^.:`
25279   new_path="$path"
25280   if test "x$has_colon" = x; then
25281     # Not in mixed or Windows style, start by that.
25282     new_path=`cmd //c echo $path`
25283   fi
25284 
25285 
25286   input_path="$new_path"
25287   # Check if we need to convert this using DOS-style short mode. If the path
25288   # contains just simple characters, use it. Otherwise (spaces, weird characters),
25289   # take no chances and rewrite it.
25290   # Note: m4 eats our [], so we need to use [ and ] instead.
25291   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
25292   if test "x$has_forbidden_chars" != x; then
25293     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
25294     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
25295   fi
25296 
25297 
25298   windows_path="$new_path"
25299   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
25300     unix_path=`$CYGPATH -u "$windows_path"`
25301     new_path="$unix_path"
25302   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
25303     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
25304     new_path="$unix_path"
25305   fi
25306 
25307   if test "x$path" != "x$new_path"; then
25308     BOOT_JDK="$new_path"
25309     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
25310 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
25311   fi
25312 
25313   # Save the first 10 bytes of this path to the storage, so fixpath can work.
25314   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
25315 
25316     else
25317       # We're on a unix platform. Hooray! :)
25318       path="$BOOT_JDK"
25319       has_space=`$ECHO "$path" | $GREP " "`
25320       if test "x$has_space" != x; then
25321         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
25322 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
25323         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
25324       fi
25325 
25326       # Use eval to expand a potential ~
25327       eval path="$path"
25328       if test ! -f "$path" && test ! -d "$path"; then
25329         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
25330       fi
25331 
25332       if test -d "$path"; then
25333         BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
25334       else
25335         dir="`$DIRNAME "$path"`"
25336         base="`$BASENAME "$path"`"
25337         BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
25338       fi
25339     fi
25340   fi
25341 
25342             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
25343 $as_echo_n "checking for Boot JDK... " >&6; }
25344             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
25345 $as_echo "$BOOT_JDK" >&6; }
25346             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
25347 $as_echo_n "checking Boot JDK version... " >&6; }
25348             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
25349             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
25350 $as_echo "$BOOT_JDK_VERSION" >&6; }
25351           fi # end check jdk version
25352         fi # end check javac
25353       fi # end check java
25354     fi # end check boot jdk found
25355   fi
25356 
25357 
25358   if test "x$BOOT_JDK_FOUND" = xno; then
25359     # Now execute the test
25360 
25361   if test -x /usr/libexec/java_home; then
25362     BOOT_JDK=`/usr/libexec/java_home -v 1.8`
25363     BOOT_JDK_FOUND=maybe
25364     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home -v 1.8" >&5
25365 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home -v 1.8" >&6;}
25366   fi
25367 
25368 
25369     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
25370     if test "x$BOOT_JDK_FOUND" = xmaybe; then
25371       # Do we have a bin/java?
25372       if test ! -x "$BOOT_JDK/bin/java"; then
25373         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
25374 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
25375         BOOT_JDK_FOUND=no
25376       else
25377         # Do we have a bin/javac?
25378         if test ! -x "$BOOT_JDK/bin/javac"; then
25379           { $as_echo "$as_me:${as_lineno-$LINE