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 NO_LIFETIME_DSE_CFLAG
 753 NO_NULL_POINTER_CHECK_CFLAG
 754 CXXSTD_CXXFLAG
 755 CXX_O_FLAG_SIZE
 756 CXX_O_FLAG_NONE
 757 CXX_O_FLAG_DEBUG
 758 CXX_O_FLAG_NORM
 759 CXX_O_FLAG_HI
 760 CXX_O_FLAG_HIGHEST
 761 CXX_O_FLAG_HIGHEST_JVM
 762 C_O_FLAG_SIZE
 763 C_O_FLAG_NONE
 764 C_O_FLAG_DEBUG
 765 C_O_FLAG_NORM
 766 C_O_FLAG_HI
 767 C_O_FLAG_HIGHEST
 768 C_O_FLAG_HIGHEST_JVM
 769 JVM_CFLAGS_SYMBOLS
 770 CXXFLAGS_DEBUG_SYMBOLS
 771 CFLAGS_DEBUG_SYMBOLS
 772 CXX_FLAG_DEPS
 773 C_FLAG_DEPS
 774 SHARED_LIBRARY_FLAGS
 775 SET_SHARED_LIBRARY_MAPFILE
 776 SET_SHARED_LIBRARY_NAME
 777 SET_SHARED_LIBRARY_ORIGIN
 778 SET_EXECUTABLE_ORIGIN
 779 CXX_FLAG_REORDER
 780 C_FLAG_REORDER
 781 JVM_RCFLAGS
 782 RC_FLAGS
 783 AR_OUT_OPTION
 784 LD_OUT_OPTION
 785 EXE_OUT_OPTION
 786 CC_OUT_OPTION
 787 STRIPFLAGS
 788 ARFLAGS
 789 COMPILER_BINDCMD_FILE_FLAG
 790 COMPILER_COMMAND_FILE_FLAG
 791 COMPILER_TARGET_BITS_FLAG
 792 JT_HOME
 793 JTREGEXE
 794 HOTSPOT_TOOLCHAIN_TYPE
 795 USING_BROKEN_SUSE_LD
 796 PACKAGE_PATH
 797 USE_CLANG
 798 HOTSPOT_LD
 799 HOTSPOT_CXX
 800 HOTSPOT_RC
 801 HOTSPOT_MT
 802 BUILD_AS
 803 BUILD_LDCXX
 804 BUILD_LD
 805 BUILD_STRIP
 806 BUILD_OBJCOPY
 807 BUILD_AR
 808 BUILD_NM
 809 BUILD_CXX
 810 BUILD_CC
 811 BUILD_SYSROOT_LDFLAGS
 812 BUILD_SYSROOT_CFLAGS
 813 ac_ct_OBJDUMP
 814 OBJDUMP
 815 ac_ct_OBJCOPY
 816 OBJCOPY
 817 ac_ct_NM
 818 ac_ct_STRIP
 819 GNM
 820 NM
 821 STRIP
 822 MSBUILD
 823 DUMPBIN
 824 RC
 825 MT
 826 LIPO
 827 ac_ct_AR
 828 AR
 829 AS
 830 LDCXX
 831 LD
 832 CXXCPP
 833 CPP
 834 CXX_VERSION_NUMBER
 835 CC_VERSION_NUMBER
 836 ac_ct_CXX
 837 CXXFLAGS
 838 CXX
 839 TOOLCHAIN_PATH_CXX
 840 POTENTIAL_CXX
 841 OBJEXT
 842 EXEEXT
 843 ac_ct_CC
 844 CPPFLAGS
 845 LDFLAGS
 846 CFLAGS
 847 CC
 848 TOOLCHAIN_PATH_CC
 849 POTENTIAL_CC
 850 TOOLCHAIN_VERSION
 851 VS_LIB
 852 VS_INCLUDE
 853 VS_PATH
 854 CYGWIN_LINK
 855 SYSROOT_LDFLAGS
 856 SYSROOT_CFLAGS
 857 EXTRA_LDFLAGS
 858 EXTRA_CXXFLAGS
 859 EXTRA_CFLAGS
 860 LEGACY_EXTRA_LDFLAGS
 861 LEGACY_EXTRA_CXXFLAGS
 862 LEGACY_EXTRA_CFLAGS
 863 EXE_SUFFIX
 864 OBJ_SUFFIX
 865 STATIC_LIBRARY
 866 SHARED_LIBRARY
 867 STATIC_LIBRARY_SUFFIX
 868 SHARED_LIBRARY_SUFFIX
 869 LIBRARY_PREFIX
 870 TOOLCHAIN_TYPE
 871 STATIC_BUILD
 872 IMPORT_MODULES_MAKE
 873 IMPORT_MODULES_SRC
 874 IMPORT_MODULES_CONF
 875 IMPORT_MODULES_LIBS
 876 IMPORT_MODULES_CMDS
 877 IMPORT_MODULES_CLASSES
 878 BUILD_HOTSPOT
 879 HOTSPOT_DIST
 880 BUILD_OUTPUT
 881 JDK_TOPDIR
 882 NASHORN_TOPDIR
 883 HOTSPOT_TOPDIR
 884 JAXWS_TOPDIR
 885 JAXP_TOPDIR
 886 CORBA_TOPDIR
 887 LANGTOOLS_TOPDIR
 888 EXTERNAL_BUILDJDK
 889 BUILD_JDK
 890 CREATE_BUILDJDK
 891 JLINK
 892 JMOD
 893 BOOT_JDK_BITS
 894 JAVAC_FLAGS
 895 BOOT_JDK_MODULAR
 896 BOOT_JDK_SOURCETARGET
 897 JARSIGNER
 898 JAR
 899 JAVAH
 900 JAVAC
 901 JAVA
 902 BOOT_JDK
 903 JAVA_CHECK
 904 JAVAC_CHECK
 905 VERSION_IS_GA
 906 VERSION_SHORT
 907 VERSION_STRING
 908 VERSION_NUMBER_FOUR_POSITIONS
 909 VERSION_NUMBER
 910 VERSION_OPT
 911 VERSION_BUILD
 912 VERSION_PRE
 913 VERSION_PATCH
 914 VERSION_SECURITY
 915 VERSION_MINOR
 916 VERSION_MAJOR
 917 MACOSX_BUNDLE_ID_BASE
 918 MACOSX_BUNDLE_NAME_BASE
 919 HOTSPOT_VM_DISTRO
 920 COMPANY_NAME
 921 JDK_RC_PLATFORM_NAME
 922 PRODUCT_SUFFIX
 923 PRODUCT_NAME
 924 LAUNCHER_NAME
 925 JLINK_KEEP_PACKAGED_MODULES
 926 COPYRIGHT_YEAR
 927 COMPRESS_JARS
 928 INCLUDE_SA
 929 UNLIMITED_CRYPTO
 930 CACERTS_FILE
 931 BUILD_HEADLESS
 932 SUPPORT_HEADFUL
 933 SUPPORT_HEADLESS
 934 DEFAULT_MAKE_TARGET
 935 OS_VERSION_MICRO
 936 OS_VERSION_MINOR
 937 OS_VERSION_MAJOR
 938 PKG_CONFIG
 939 BASH_ARGS
 940 SETFILE
 941 CODESIGN
 942 XATTR
 943 DSYMUTIL
 944 IS_GNU_TIME
 945 PATCH
 946 DTRACE
 947 TIME
 948 STAT
 949 HG
 950 READELF
 951 OTOOL
 952 LDD
 953 ZIP
 954 UNZIP
 955 TAR_SUPPORTS_TRANSFORM
 956 TAR_INCLUDE_PARAM
 957 TAR_CREATE_EXTRA_PARAM
 958 TAR_TYPE
 959 FIND_DELETE
 960 OUTPUT_SYNC
 961 OUTPUT_SYNC_SUPPORTED
 962 CHECK_TOOLSDIR_MAKE
 963 CHECK_TOOLSDIR_GMAKE
 964 CHECK_MAKE
 965 CHECK_GMAKE
 966 MAKE
 967 PKGHANDLER
 968 CONFIGURESUPPORT_OUTPUTDIR
 969 OUTPUT_ROOT
 970 CONF_NAME
 971 SPEC
 972 SDKROOT
 973 XCODEBUILD
 974 VALID_JVM_VARIANTS
 975 JVM_VARIANTS
 976 DEBUG_LEVEL
 977 HOTSPOT_DEBUG_LEVEL
 978 JDK_VARIANT
 979 USERNAME
 980 CANONICAL_TOPDIR
 981 ORIGINAL_TOPDIR
 982 TOPDIR
 983 PATH_SEP
 984 ZERO_ARCHDEF
 985 HOTSPOT_BUILD_CPU_DEFINE
 986 HOTSPOT_BUILD_CPU_ARCH
 987 HOTSPOT_BUILD_CPU
 988 HOTSPOT_BUILD_OS_TYPE
 989 HOTSPOT_BUILD_OS
 990 OPENJDK_BUILD_BUNDLE_PLATFORM
 991 OPENJDK_BUILD_CPU_BUNDLE
 992 OPENJDK_BUILD_OS_BUNDLE
 993 OPENJDK_BUILD_OS_EXPORT_DIR
 994 OPENJDK_BUILD_CPU_JLI_CFLAGS
 995 OPENJDK_BUILD_CPU_OSARCH
 996 OPENJDK_BUILD_CPU_ISADIR
 997 OPENJDK_BUILD_CPU_LIBDIR
 998 OPENJDK_BUILD_CPU_LEGACY_LIB
 999 OPENJDK_BUILD_CPU_LEGACY
1000 HOTSPOT_TARGET_CPU_DEFINE
1001 HOTSPOT_TARGET_CPU_ARCH
1002 HOTSPOT_TARGET_CPU
1003 HOTSPOT_TARGET_OS_TYPE
1004 HOTSPOT_TARGET_OS
1005 DEFINE_CROSS_COMPILE_ARCH
1006 LP64
1007 OPENJDK_TARGET_BUNDLE_PLATFORM
1008 OPENJDK_TARGET_CPU_BUNDLE
1009 OPENJDK_TARGET_OS_BUNDLE
1010 OPENJDK_TARGET_OS_EXPORT_DIR
1011 OPENJDK_TARGET_CPU_JLI_CFLAGS
1012 OPENJDK_TARGET_CPU_OSARCH
1013 OPENJDK_TARGET_CPU_ISADIR
1014 OPENJDK_TARGET_CPU_LIBDIR
1015 OPENJDK_TARGET_CPU_LEGACY_LIB
1016 OPENJDK_TARGET_CPU_LEGACY
1017 REQUIRED_OS_VERSION
1018 REQUIRED_OS_NAME
1019 COMPILE_TYPE
1020 OPENJDK_TARGET_CPU_ENDIAN
1021 OPENJDK_TARGET_CPU_BITS
1022 OPENJDK_TARGET_CPU_ARCH
1023 OPENJDK_TARGET_CPU
1024 OPENJDK_TARGET_OS_ENV
1025 OPENJDK_TARGET_OS_TYPE
1026 OPENJDK_TARGET_OS
1027 OPENJDK_BUILD_CPU_ENDIAN
1028 OPENJDK_BUILD_CPU_BITS
1029 OPENJDK_BUILD_CPU_ARCH
1030 OPENJDK_BUILD_CPU
1031 OPENJDK_BUILD_OS_ENV
1032 OPENJDK_BUILD_OS_TYPE
1033 OPENJDK_BUILD_OS
1034 OPENJDK_BUILD_AUTOCONF_NAME
1035 OPENJDK_TARGET_AUTOCONF_NAME
1036 target_os
1037 target_vendor
1038 target_cpu
1039 target
1040 host_os
1041 host_vendor
1042 host_cpu
1043 host
1044 build_os
1045 build_vendor
1046 build_cpu
1047 build
1048 NICE
1049 CPIO
1050 DF
1051 READLINK
1052 CYGPATH
1053 SED
1054 FGREP
1055 EGREP
1056 GREP
1057 AWK
1058 XARGS
1059 WHICH
1060 WC
1061 UNIQ
1062 UNAME
1063 TR
1064 TOUCH
1065 TEE
1066 TAR
1067 TAIL
1068 SORT
1069 SH
1070 RMDIR
1071 RM
1072 PRINTF
1073 NAWK
1074 MV
1075 MKTEMP
1076 MKDIR
1077 LS
1078 LN
1079 GZIP
1080 GUNZIP
1081 HEAD
1082 FIND
1083 FILE
1084 EXPR
1085 ECHO
1086 DIRNAME
1087 DIFF
1088 DATE
1089 CUT
1090 CP
1091 COMM
1092 CMP
1093 CHMOD
1094 CAT
1095 BASH
1096 BASENAME
1097 DATE_WHEN_CONFIGURED
1098 ORIGINAL_PATH
1099 CONFIGURE_COMMAND_LINE
1100 target_alias
1101 host_alias
1102 build_alias
1103 LIBS
1104 ECHO_T
1105 ECHO_N
1106 ECHO_C
1107 DEFS
1108 mandir
1109 localedir
1110 libdir
1111 psdir
1112 pdfdir
1113 dvidir
1114 htmldir
1115 infodir
1116 docdir
1117 oldincludedir
1118 includedir
1119 localstatedir
1120 sharedstatedir
1121 sysconfdir
1122 datadir
1123 datarootdir
1124 libexecdir
1125 sbindir
1126 bindir
1127 program_transform_name
1128 prefix
1129 exec_prefix
1130 PACKAGE_URL
1131 PACKAGE_BUGREPORT
1132 PACKAGE_STRING
1133 PACKAGE_VERSION
1134 PACKAGE_TARNAME
1135 PACKAGE_NAME
1136 PATH_SEPARATOR
1137 SHELL'
1138 ac_subst_files=''
1139 ac_user_opts='
1140 enable_option_checking
1141 with_target_bits
1142 enable_openjdk_only
1143 with_custom_make_dir
1144 with_jdk_variant
1145 enable_debug
1146 with_debug_level
1147 with_jvm_variants
1148 with_devkit
1149 with_sys_root
1150 with_sysroot
1151 with_tools_dir
1152 with_toolchain_path
1153 with_extra_path
1154 with_sdk_name
1155 with_conf_name
1156 with_output_sync
1157 with_default_make_target
1158 enable_headful
1159 with_cacerts_file
1160 enable_unlimited_crypto
1161 with_copyright_year
1162 enable_keep_packaged_modules
1163 with_milestone
1164 with_update_version
1165 with_user_release_suffix
1166 with_build_number
1167 with_version_string
1168 with_version_pre
1169 with_version_opt
1170 with_version_build
1171 with_version_major
1172 with_version_minor
1173 with_version_security
1174 with_version_patch
1175 with_boot_jdk
1176 with_build_jdk
1177 with_add_source_root
1178 with_override_source_root
1179 with_adds_and_overrides
1180 with_override_langtools
1181 with_override_corba
1182 with_override_jaxp
1183 with_override_jaxws
1184 with_override_hotspot
1185 with_override_nashorn
1186 with_override_jdk
1187 with_import_hotspot
1188 with_import_modules
1189 enable_static_build
1190 with_toolchain_type
1191 with_extra_cflags
1192 with_extra_cxxflags
1193 with_extra_ldflags
1194 with_toolchain_version
1195 with_build_devkit
1196 with_jtreg
1197 enable_warnings_as_errors
1198 with_native_debug_symbols
1199 enable_debug_symbols
1200 enable_zip_debug_info
1201 enable_native_coverage
1202 enable_dtrace
1203 with_jvm_features
1204 with_jvm_interpreter
1205 enable_hotspot_gtest
1206 with_stdc__lib
1207 with_msvcr_dll
1208 with_msvcp_dll
1209 with_x
1210 with_cups
1211 with_cups_include
1212 with_freetype
1213 with_freetype_include
1214 with_freetype_lib
1215 with_freetype_src
1216 enable_freetype_bundling
1217 with_alsa
1218 with_alsa_include
1219 with_alsa_lib
1220 with_libffi
1221 with_libffi_include
1222 with_libffi_lib
1223 with_libjpeg
1224 with_giflib
1225 with_libpng
1226 with_zlib
1227 with_lcms
1228 with_dxsdk
1229 with_dxsdk_lib
1230 with_dxsdk_include
1231 enable_jtreg_failure_handler
1232 enable_generate_classlist
1233 with_num_cores
1234 with_memory_size
1235 with_jobs
1236 with_test_jobs
1237 with_boot_jdk_jvmargs
1238 with_sjavac_server_java
1239 enable_sjavac
1240 enable_javac_server
1241 enable_icecc
1242 enable_precompiled_headers
1243 enable_ccache
1244 with_ccache_dir
1245 '
1246       ac_precious_vars='build_alias
1247 host_alias
1248 target_alias
1249 BASENAME
1250 BASH
1251 CAT
1252 CHMOD
1253 CMP
1254 COMM
1255 CP
1256 CUT
1257 DATE
1258 DIFF
1259 DIRNAME
1260 ECHO
1261 EXPR
1262 FILE
1263 FIND
1264 HEAD
1265 GUNZIP
1266 GZIP
1267 LN
1268 LS
1269 MKDIR
1270 MKTEMP
1271 MV
1272 NAWK
1273 PRINTF
1274 RM
1275 RMDIR
1276 SH
1277 SORT
1278 TAIL
1279 TAR
1280 TEE
1281 TOUCH
1282 TR
1283 UNAME
1284 UNIQ
1285 WC
1286 WHICH
1287 XARGS
1288 AWK
1289 GREP
1290 EGREP
1291 FGREP
1292 SED
1293 CYGPATH
1294 READLINK
1295 DF
1296 CPIO
1297 NICE
1298 MAKE
1299 UNZIP
1300 ZIP
1301 LDD
1302 OTOOL
1303 READELF
1304 HG
1305 STAT
1306 TIME
1307 DTRACE
1308 PATCH
1309 DSYMUTIL
1310 XATTR
1311 CODESIGN
1312 SETFILE
1313 PKG_CONFIG
1314 JAVA
1315 JAVAC
1316 JAVAH
1317 JAR
1318 JARSIGNER
1319 CC
1320 CFLAGS
1321 LDFLAGS
1322 LIBS
1323 CPPFLAGS
1324 CXX
1325 CXXFLAGS
1326 CCC
1327 CPP
1328 CXXCPP
1329 AS
1330 AR
1331 LIPO
1332 STRIP
1333 NM
1334 GNM
1335 OBJCOPY
1336 OBJDUMP
1337 BUILD_CC
1338 BUILD_CXX
1339 BUILD_NM
1340 BUILD_AR
1341 BUILD_OBJCOPY
1342 BUILD_STRIP
1343 JTREGEXE
1344 XMKMF
1345 FREETYPE_CFLAGS
1346 FREETYPE_LIBS
1347 ALSA_CFLAGS
1348 ALSA_LIBS
1349 LIBFFI_CFLAGS
1350 LIBFFI_LIBS
1351 PNG_CFLAGS
1352 PNG_LIBS
1353 LCMS_CFLAGS
1354 LCMS_LIBS
1355 ICECC_CMD
1356 ICECC_CREATE_ENV
1357 ICECC_WRAPPER
1358 CCACHE'
1359 
1360 
1361 # Initialize some variables set by options.
1362 ac_init_help=
1363 ac_init_version=false
1364 ac_unrecognized_opts=
1365 ac_unrecognized_sep=
1366 # The variables have the same names as the options, with
1367 # dashes changed to underlines.
1368 cache_file=/dev/null
1369 exec_prefix=NONE
1370 no_create=
1371 no_recursion=
1372 prefix=NONE
1373 program_prefix=NONE
1374 program_suffix=NONE
1375 program_transform_name=s,x,x,
1376 silent=
1377 site=
1378 srcdir=
1379 verbose=
1380 x_includes=NONE
1381 x_libraries=NONE
1382 
1383 # Installation directory options.
1384 # These are left unexpanded so users can "make install exec_prefix=/foo"
1385 # and all the variables that are supposed to be based on exec_prefix
1386 # by default will actually change.
1387 # Use braces instead of parens because sh, perl, etc. also accept them.
1388 # (The list follows the same order as the GNU Coding Standards.)
1389 bindir='${exec_prefix}/bin'
1390 sbindir='${exec_prefix}/sbin'
1391 libexecdir='${exec_prefix}/libexec'
1392 datarootdir='${prefix}/share'
1393 datadir='${datarootdir}'
1394 sysconfdir='${prefix}/etc'
1395 sharedstatedir='${prefix}/com'
1396 localstatedir='${prefix}/var'
1397 includedir='${prefix}/include'
1398 oldincludedir='/usr/include'
1399 docdir='${datarootdir}/doc/${PACKAGE_TARNAME}'
1400 infodir='${datarootdir}/info'
1401 htmldir='${docdir}'
1402 dvidir='${docdir}'
1403 pdfdir='${docdir}'
1404 psdir='${docdir}'
1405 libdir='${exec_prefix}/lib'
1406 localedir='${datarootdir}/locale'
1407 mandir='${datarootdir}/man'
1408 
1409 ac_prev=
1410 ac_dashdash=
1411 for ac_option
1412 do
1413   # If the previous option needs an argument, assign it.
1414   if test -n "$ac_prev"; then
1415     eval $ac_prev=\$ac_option
1416     ac_prev=
1417     continue
1418   fi
1419 
1420   case $ac_option in
1421   *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
1422   *=)   ac_optarg= ;;
1423   *)    ac_optarg=yes ;;
1424   esac
1425 
1426   # Accept the important Cygnus configure options, so we can diagnose typos.
1427 
1428   case $ac_dashdash$ac_option in
1429   --)
1430     ac_dashdash=yes ;;
1431 
1432   -bindir | --bindir | --bindi | --bind | --bin | --bi)
1433     ac_prev=bindir ;;
1434   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
1435     bindir=$ac_optarg ;;
1436 
1437   -build | --build | --buil | --bui | --bu)
1438     ac_prev=build_alias ;;
1439   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
1440     build_alias=$ac_optarg ;;
1441 
1442   -cache-file | --cache-file | --cache-fil | --cache-fi \
1443   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
1444     ac_prev=cache_file ;;
1445   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
1446   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
1447     cache_file=$ac_optarg ;;
1448 
1449   --config-cache | -C)
1450     cache_file=config.cache ;;
1451 
1452   -datadir | --datadir | --datadi | --datad)
1453     ac_prev=datadir ;;
1454   -datadir=* | --datadir=* | --datadi=* | --datad=*)
1455     datadir=$ac_optarg ;;
1456 
1457   -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \
1458   | --dataroo | --dataro | --datar)
1459     ac_prev=datarootdir ;;
1460   -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \
1461   | --dataroot=* | --dataroo=* | --dataro=* | --datar=*)
1462     datarootdir=$ac_optarg ;;
1463 
1464   -disable-* | --disable-*)
1465     ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
1466     # Reject names that are not valid shell variable names.
1467     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1468       as_fn_error $? "invalid feature name: $ac_useropt"
1469     ac_useropt_orig=$ac_useropt
1470     ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1471     case $ac_user_opts in
1472       *"
1473 "enable_$ac_useropt"
1474 "*) ;;
1475       *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig"
1476          ac_unrecognized_sep=', ';;
1477     esac
1478     eval enable_$ac_useropt=no ;;
1479 
1480   -docdir | --docdir | --docdi | --doc | --do)
1481     ac_prev=docdir ;;
1482   -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*)
1483     docdir=$ac_optarg ;;
1484 
1485   -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv)
1486     ac_prev=dvidir ;;
1487   -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*)
1488     dvidir=$ac_optarg ;;
1489 
1490   -enable-* | --enable-*)
1491     ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
1492     # Reject names that are not valid shell variable names.
1493     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1494       as_fn_error $? "invalid feature name: $ac_useropt"
1495     ac_useropt_orig=$ac_useropt
1496     ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1497     case $ac_user_opts in
1498       *"
1499 "enable_$ac_useropt"
1500 "*) ;;
1501       *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig"
1502          ac_unrecognized_sep=', ';;
1503     esac
1504     eval enable_$ac_useropt=\$ac_optarg ;;
1505 
1506   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
1507   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
1508   | --exec | --exe | --ex)
1509     ac_prev=exec_prefix ;;
1510   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
1511   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
1512   | --exec=* | --exe=* | --ex=*)
1513     exec_prefix=$ac_optarg ;;
1514 
1515   -gas | --gas | --ga | --g)
1516     # Obsolete; use --with-gas.
1517     with_gas=yes ;;
1518 
1519   -help | --help | --hel | --he | -h)
1520     ac_init_help=long ;;
1521   -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
1522     ac_init_help=recursive ;;
1523   -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
1524     ac_init_help=short ;;
1525 
1526   -host | --host | --hos | --ho)
1527     ac_prev=host_alias ;;
1528   -host=* | --host=* | --hos=* | --ho=*)
1529     host_alias=$ac_optarg ;;
1530 
1531   -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht)
1532     ac_prev=htmldir ;;
1533   -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \
1534   | --ht=*)
1535     htmldir=$ac_optarg ;;
1536 
1537   -includedir | --includedir | --includedi | --included | --include \
1538   | --includ | --inclu | --incl | --inc)
1539     ac_prev=includedir ;;
1540   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
1541   | --includ=* | --inclu=* | --incl=* | --inc=*)
1542     includedir=$ac_optarg ;;
1543 
1544   -infodir | --infodir | --infodi | --infod | --info | --inf)
1545     ac_prev=infodir ;;
1546   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
1547     infodir=$ac_optarg ;;
1548 
1549   -libdir | --libdir | --libdi | --libd)
1550     ac_prev=libdir ;;
1551   -libdir=* | --libdir=* | --libdi=* | --libd=*)
1552     libdir=$ac_optarg ;;
1553 
1554   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
1555   | --libexe | --libex | --libe)
1556     ac_prev=libexecdir ;;
1557   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
1558   | --libexe=* | --libex=* | --libe=*)
1559     libexecdir=$ac_optarg ;;
1560 
1561   -localedir | --localedir | --localedi | --localed | --locale)
1562     ac_prev=localedir ;;
1563   -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*)
1564     localedir=$ac_optarg ;;
1565 
1566   -localstatedir | --localstatedir | --localstatedi | --localstated \
1567   | --localstate | --localstat | --localsta | --localst | --locals)
1568     ac_prev=localstatedir ;;
1569   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
1570   | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*)
1571     localstatedir=$ac_optarg ;;
1572 
1573   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
1574     ac_prev=mandir ;;
1575   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
1576     mandir=$ac_optarg ;;
1577 
1578   -nfp | --nfp | --nf)
1579     # Obsolete; use --without-fp.
1580     with_fp=no ;;
1581 
1582   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
1583   | --no-cr | --no-c | -n)
1584     no_create=yes ;;
1585 
1586   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
1587   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
1588     no_recursion=yes ;;
1589 
1590   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
1591   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
1592   | --oldin | --oldi | --old | --ol | --o)
1593     ac_prev=oldincludedir ;;
1594   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
1595   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
1596   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
1597     oldincludedir=$ac_optarg ;;
1598 
1599   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
1600     ac_prev=prefix ;;
1601   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
1602     prefix=$ac_optarg ;;
1603 
1604   -program-prefix | --program-prefix | --program-prefi | --program-pref \
1605   | --program-pre | --program-pr | --program-p)
1606     ac_prev=program_prefix ;;
1607   -program-prefix=* | --program-prefix=* | --program-prefi=* \
1608   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
1609     program_prefix=$ac_optarg ;;
1610 
1611   -program-suffix | --program-suffix | --program-suffi | --program-suff \
1612   | --program-suf | --program-su | --program-s)
1613     ac_prev=program_suffix ;;
1614   -program-suffix=* | --program-suffix=* | --program-suffi=* \
1615   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
1616     program_suffix=$ac_optarg ;;
1617 
1618   -program-transform-name | --program-transform-name \
1619   | --program-transform-nam | --program-transform-na \
1620   | --program-transform-n | --program-transform- \
1621   | --program-transform | --program-transfor \
1622   | --program-transfo | --program-transf \
1623   | --program-trans | --program-tran \
1624   | --progr-tra | --program-tr | --program-t)
1625     ac_prev=program_transform_name ;;
1626   -program-transform-name=* | --program-transform-name=* \
1627   | --program-transform-nam=* | --program-transform-na=* \
1628   | --program-transform-n=* | --program-transform-=* \
1629   | --program-transform=* | --program-transfor=* \
1630   | --program-transfo=* | --program-transf=* \
1631   | --program-trans=* | --program-tran=* \
1632   | --progr-tra=* | --program-tr=* | --program-t=*)
1633     program_transform_name=$ac_optarg ;;
1634 
1635   -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd)
1636     ac_prev=pdfdir ;;
1637   -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*)
1638     pdfdir=$ac_optarg ;;
1639 
1640   -psdir | --psdir | --psdi | --psd | --ps)
1641     ac_prev=psdir ;;
1642   -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)
1643     psdir=$ac_optarg ;;
1644 
1645   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1646   | -silent | --silent | --silen | --sile | --sil)
1647     silent=yes ;;
1648 
1649   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
1650     ac_prev=sbindir ;;
1651   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
1652   | --sbi=* | --sb=*)
1653     sbindir=$ac_optarg ;;
1654 
1655   -sharedstatedir | --sharedstatedir | --sharedstatedi \
1656   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
1657   | --sharedst | --shareds | --shared | --share | --shar \
1658   | --sha | --sh)
1659     ac_prev=sharedstatedir ;;
1660   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
1661   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
1662   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
1663   | --sha=* | --sh=*)
1664     sharedstatedir=$ac_optarg ;;
1665 
1666   -site | --site | --sit)
1667     ac_prev=site ;;
1668   -site=* | --site=* | --sit=*)
1669     site=$ac_optarg ;;
1670 
1671   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
1672     ac_prev=srcdir ;;
1673   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
1674     srcdir=$ac_optarg ;;
1675 
1676   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
1677   | --syscon | --sysco | --sysc | --sys | --sy)
1678     ac_prev=sysconfdir ;;
1679   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
1680   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
1681     sysconfdir=$ac_optarg ;;
1682 
1683   -target | --target | --targe | --targ | --tar | --ta | --t)
1684     ac_prev=target_alias ;;
1685   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
1686     target_alias=$ac_optarg ;;
1687 
1688   -v | -verbose | --verbose | --verbos | --verbo | --verb)
1689     verbose=yes ;;
1690 
1691   -version | --version | --versio | --versi | --vers | -V)
1692     ac_init_version=: ;;
1693 
1694   -with-* | --with-*)
1695     ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
1696     # Reject names that are not valid shell variable names.
1697     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1698       as_fn_error $? "invalid package name: $ac_useropt"
1699     ac_useropt_orig=$ac_useropt
1700     ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1701     case $ac_user_opts in
1702       *"
1703 "with_$ac_useropt"
1704 "*) ;;
1705       *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig"
1706          ac_unrecognized_sep=', ';;
1707     esac
1708     eval with_$ac_useropt=\$ac_optarg ;;
1709 
1710   -without-* | --without-*)
1711     ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'`
1712     # Reject names that are not valid shell variable names.
1713     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1714       as_fn_error $? "invalid package name: $ac_useropt"
1715     ac_useropt_orig=$ac_useropt
1716     ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1717     case $ac_user_opts in
1718       *"
1719 "with_$ac_useropt"
1720 "*) ;;
1721       *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig"
1722          ac_unrecognized_sep=', ';;
1723     esac
1724     eval with_$ac_useropt=no ;;
1725 
1726   --x)
1727     # Obsolete; use --with-x.
1728     with_x=yes ;;
1729 
1730   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
1731   | --x-incl | --x-inc | --x-in | --x-i)
1732     ac_prev=x_includes ;;
1733   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
1734   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
1735     x_includes=$ac_optarg ;;
1736 
1737   -x-libraries | --x-libraries | --x-librarie | --x-librari \
1738   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
1739     ac_prev=x_libraries ;;
1740   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
1741   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
1742     x_libraries=$ac_optarg ;;
1743 
1744   -*) as_fn_error $? "unrecognized option: \`$ac_option'
1745 Try \`$0 --help' for more information"
1746     ;;
1747 
1748   *=*)
1749     ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
1750     # Reject names that are not valid shell variable names.
1751     case $ac_envvar in #(
1752       '' | [0-9]* | *[!_$as_cr_alnum]* )
1753       as_fn_error $? "invalid variable name: \`$ac_envvar'" ;;
1754     esac
1755     eval $ac_envvar=\$ac_optarg
1756     export $ac_envvar ;;
1757 
1758   *)
1759     # FIXME: should be removed in autoconf 3.0.
1760     $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2
1761     expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
1762       $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2
1763     : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}"
1764     ;;
1765 
1766   esac
1767 done
1768 
1769 if test -n "$ac_prev"; then
1770   ac_option=--`echo $ac_prev | sed 's/_/-/g'`
1771   as_fn_error $? "missing argument to $ac_option"
1772 fi
1773 
1774 if test -n "$ac_unrecognized_opts"; then
1775   case $enable_option_checking in
1776     no) ;;
1777     fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;;
1778     *)     $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
1779   esac
1780 fi
1781 
1782 # Check all directory arguments for consistency.
1783 for ac_var in   exec_prefix prefix bindir sbindir libexecdir datarootdir \
1784                 datadir sysconfdir sharedstatedir localstatedir includedir \
1785                 oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
1786                 libdir localedir mandir
1787 do
1788   eval ac_val=\$$ac_var
1789   # Remove trailing slashes.
1790   case $ac_val in
1791     */ )
1792       ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'`
1793       eval $ac_var=\$ac_val;;
1794   esac
1795   # Be sure to have absolute directory names.
1796   case $ac_val in
1797     [\\/$]* | ?:[\\/]* )  continue;;
1798     NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
1799   esac
1800   as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val"
1801 done
1802 
1803 # There might be people who depend on the old broken behavior: `$host'
1804 # used to hold the argument of --host etc.
1805 # FIXME: To remove some day.
1806 build=$build_alias
1807 host=$host_alias
1808 target=$target_alias
1809 
1810 # FIXME: To remove some day.
1811 if test "x$host_alias" != x; then
1812   if test "x$build_alias" = x; then
1813     cross_compiling=maybe
1814   elif test "x$build_alias" != "x$host_alias"; then
1815     cross_compiling=yes
1816   fi
1817 fi
1818 
1819 ac_tool_prefix=
1820 test -n "$host_alias" && ac_tool_prefix=$host_alias-
1821 
1822 test "$silent" = yes && exec 6>/dev/null
1823 
1824 
1825 ac_pwd=`pwd` && test -n "$ac_pwd" &&
1826 ac_ls_di=`ls -di .` &&
1827 ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
1828   as_fn_error $? "working directory cannot be determined"
1829 test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
1830   as_fn_error $? "pwd does not report name of working directory"
1831 
1832 
1833 # Find the source files, if location was not specified.
1834 if test -z "$srcdir"; then
1835   ac_srcdir_defaulted=yes
1836   # Try the directory containing this script, then the parent directory.
1837   ac_confdir=`$as_dirname -- "$as_myself" ||
1838 $as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
1839          X"$as_myself" : 'X\(//\)[^/]' \| \
1840          X"$as_myself" : 'X\(//\)$' \| \
1841          X"$as_myself" : 'X\(/\)' \| . 2>/dev/null ||
1842 $as_echo X"$as_myself" |
1843     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
1844             s//\1/
1845             q
1846           }
1847           /^X\(\/\/\)[^/].*/{
1848             s//\1/
1849             q
1850           }
1851           /^X\(\/\/\)$/{
1852             s//\1/
1853             q
1854           }
1855           /^X\(\/\).*/{
1856             s//\1/
1857             q
1858           }
1859           s/.*/./; q'`
1860   srcdir=$ac_confdir
1861   if test ! -r "$srcdir/$ac_unique_file"; then
1862     srcdir=..
1863   fi
1864 else
1865   ac_srcdir_defaulted=no
1866 fi
1867 if test ! -r "$srcdir/$ac_unique_file"; then
1868   test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
1869   as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir"
1870 fi
1871 ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
1872 ac_abs_confdir=`(
1873         cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg"
1874         pwd)`
1875 # When building in place, set srcdir=.
1876 if test "$ac_abs_confdir" = "$ac_pwd"; then
1877   srcdir=.
1878 fi
1879 # Remove unnecessary trailing slashes from srcdir.
1880 # Double slashes in file names in object file debugging info
1881 # mess up M-x gdb in Emacs.
1882 case $srcdir in
1883 */) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;;
1884 esac
1885 for ac_var in $ac_precious_vars; do
1886   eval ac_env_${ac_var}_set=\${${ac_var}+set}
1887   eval ac_env_${ac_var}_value=\$${ac_var}
1888   eval ac_cv_env_${ac_var}_set=\${${ac_var}+set}
1889   eval ac_cv_env_${ac_var}_value=\$${ac_var}
1890 done
1891 
1892 #
1893 # Report the --help message.
1894 #
1895 if test "$ac_init_help" = "long"; then
1896   # Omit some internal or obsolete options to make the list less imposing.
1897   # This message is too long to be a string in the A/UX 3.1 sh.
1898   cat <<_ACEOF
1899 \`configure' configures OpenJDK jdk9 to adapt to many kinds of systems.
1900 
1901 Usage: $0 [OPTION]... [VAR=VALUE]...
1902 
1903 To assign environment variables (e.g., CC, CFLAGS...), specify them as
1904 VAR=VALUE.  See below for descriptions of some of the useful variables.
1905 
1906 Defaults for the options are specified in brackets.
1907 
1908 Configuration:
1909   -h, --help              display this help and exit
1910       --help=short        display options specific to this package
1911       --help=recursive    display the short help of all the included packages
1912   -V, --version           display version information and exit
1913   -q, --quiet, --silent   do not print \`checking ...' messages
1914       --cache-file=FILE   cache test results in FILE [disabled]
1915   -C, --config-cache      alias for \`--cache-file=config.cache'
1916   -n, --no-create         do not create output files
1917       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
1918 
1919 Installation directories:
1920   --prefix=PREFIX         install architecture-independent files in PREFIX
1921                           [$ac_default_prefix]
1922   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
1923                           [PREFIX]
1924 
1925 By default, \`make install' will install all the files in
1926 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
1927 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
1928 for instance \`--prefix=\$HOME'.
1929 
1930 For better control, use the options below.
1931 
1932 Fine tuning of the installation directories:
1933   --bindir=DIR            user executables [EPREFIX/bin]
1934   --sbindir=DIR           system admin executables [EPREFIX/sbin]
1935   --libexecdir=DIR        program executables [EPREFIX/libexec]
1936   --sysconfdir=DIR        read-only single-machine data [PREFIX/etc]
1937   --sharedstatedir=DIR    modifiable architecture-independent data [PREFIX/com]
1938   --localstatedir=DIR     modifiable single-machine data [PREFIX/var]
1939   --libdir=DIR            object code libraries [EPREFIX/lib]
1940   --includedir=DIR        C header files [PREFIX/include]
1941   --oldincludedir=DIR     C header files for non-gcc [/usr/include]
1942   --datarootdir=DIR       read-only arch.-independent data root [PREFIX/share]
1943   --datadir=DIR           read-only architecture-independent data [DATAROOTDIR]
1944   --infodir=DIR           info documentation [DATAROOTDIR/info]
1945   --localedir=DIR         locale-dependent data [DATAROOTDIR/locale]
1946   --mandir=DIR            man documentation [DATAROOTDIR/man]
1947   --docdir=DIR            documentation root [DATAROOTDIR/doc/openjdk]
1948   --htmldir=DIR           html documentation [DOCDIR]
1949   --dvidir=DIR            dvi documentation [DOCDIR]
1950   --pdfdir=DIR            pdf documentation [DOCDIR]
1951   --psdir=DIR             ps documentation [DOCDIR]
1952 _ACEOF
1953 
1954   cat <<\_ACEOF
1955 
1956 X features:
1957   --x-includes=DIR    X include files are in DIR
1958   --x-libraries=DIR   X library files are in DIR
1959 
1960 System types:
1961   --build=BUILD     configure for building on BUILD [guessed]
1962   --host=HOST       cross-compile to build programs to run on HOST [BUILD]
1963   --target=TARGET   configure for building compilers for TARGET [HOST]
1964 _ACEOF
1965 fi
1966 
1967 if test -n "$ac_init_help"; then
1968   case $ac_init_help in
1969      short | recursive ) echo "Configuration of OpenJDK jdk9:";;
1970    esac
1971   cat <<\_ACEOF
1972 
1973 Optional Features:
1974   --disable-option-checking  ignore unrecognized --enable/--with options
1975   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
1976   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
1977   --enable-openjdk-only   suppress building custom source even if present
1978                           [disabled]
1979   --enable-debug          set the debug level to fastdebug (shorthand for
1980                           --with-debug-level=fastdebug) [disabled]
1981   --disable-headful       disable building headful support (graphical UI
1982                           support) [enabled]
1983   --enable-unlimited-crypto
1984                           Enable unlimited crypto policy [disabled]
1985   --disable-keep-packaged-modules
1986                           Do not keep packaged modules in jdk image [enable]
1987   --enable-static-build   enable static library build [disabled]
1988   --disable-warnings-as-errors
1989                           do not consider native warnings to be an error
1990                           [enabled]
1991   --enable-debug-symbols  Deprecated. Option is kept for backwards
1992                           compatibility and is ignored
1993   --enable-zip-debug-info Deprecated. Option is kept for backwards
1994                           compatibility and is ignored
1995   --enable-native-coverage
1996                           enable native compilation with code coverage
1997                           data[disabled]
1998   --enable-dtrace[=yes/no/auto]
1999                           enable dtrace. Default is auto, where dtrace is
2000                           enabled if all dependencies are present.
2001   --disable-hotspot-gtest Disables building of the Hotspot unit tests
2002   --disable-freetype-bundling
2003                           disable bundling of the freetype library with the
2004                           build result [enabled on Windows or when using
2005                           --with-freetype, disabled otherwise]
2006   --enable-jtreg-failure-handler
2007                           forces build of the jtreg failure handler to be
2008                           enabled, missing dependencies become fatal errors.
2009                           Default is auto, where the failure handler is built
2010                           if all dependencies are present and otherwise just
2011                           disabled.
2012   --disable-generate-classlist
2013                           forces enabling or disabling of the generation of a
2014                           CDS classlist at build time. Default is to generate
2015                           it when either the server or client JVMs are built.
2016   --enable-sjavac         use sjavac to do fast incremental compiles
2017                           [disabled]
2018   --disable-javac-server  disable javac server [enabled]
2019   --enable-icecc          enable distribted compilation of native code using
2020                           icecc/icecream [disabled]
2021   --disable-precompiled-headers
2022                           disable using precompiled headers when compiling C++
2023                           [enabled]
2024   --enable-ccache         enable using ccache to speed up recompilations
2025                           [disabled]
2026 
2027 Optional Packages:
2028   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
2029   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
2030   --with-target-bits      build 32-bit or 64-bit binaries (for platforms that
2031                           support it), e.g. --with-target-bits=32 [guessed]
2032   --with-custom-make-dir  Deprecated. Option is kept for backwards
2033                           compatibility and is ignored
2034   --with-jdk-variant      JDK variant to build (normal) [normal]
2035   --with-debug-level      set the debug level (release, fastdebug, slowdebug,
2036                           optimized) [release]
2037   --with-jvm-variants     JVM variants (separated by commas) to build
2038                           (server,client,minimal,core,zero,zeroshark,custom)
2039                           [server]
2040   --with-devkit           use this devkit for compilers, tools and resources
2041   --with-sys-root         alias for --with-sysroot for backwards compatability
2042   --with-sysroot          use this directory as sysroot
2043   --with-tools-dir        alias for --with-toolchain-path for backwards
2044                           compatibility
2045   --with-toolchain-path   prepend these directories when searching for
2046                           toolchain binaries (compilers etc)
2047   --with-extra-path       prepend these directories to the default path
2048   --with-sdk-name         use the platform SDK of the given name. [macosx]
2049   --with-conf-name        use this as the name of the configuration [generated
2050                           from important configuration options]
2051   --with-output-sync      set make output sync type if supported by make.
2052                           [recurse]
2053   --with-default-make-target
2054                           set the default make target [exploded-image]
2055   --with-cacerts-file     specify alternative cacerts file
2056   --with-copyright-year   Set copyright year value for build [current year]
2057   --with-milestone        Deprecated. Option is kept for backwards
2058                           compatibility and is ignored
2059   --with-update-version   Deprecated. Option is kept for backwards
2060                           compatibility and is ignored
2061   --with-user-release-suffix
2062                           Deprecated. Option is kept for backwards
2063                           compatibility and is ignored
2064   --with-build-number     Deprecated. Option is kept for backwards
2065                           compatibility and is ignored
2066   --with-version-string   Set version string [calculated]
2067   --with-version-pre      Set the base part of the version 'PRE' field
2068                           (pre-release identifier) ['internal']
2069   --with-version-opt      Set version 'OPT' field (build metadata)
2070                           [<timestamp>.<user>.<dirname>]
2071   --with-version-build    Set version 'BUILD' field (build number) [not
2072                           specified]
2073   --with-version-major    Set version 'MAJOR' field (first number) [current
2074                           source value]
2075   --with-version-minor    Set version 'MINOR' field (second number) [current
2076                           source value]
2077   --with-version-security Set version 'SECURITY' field (third number) [current
2078                           source value]
2079   --with-version-patch    Set version 'PATCH' field (fourth number) [not
2080                           specified]
2081   --with-boot-jdk         path to Boot JDK (used to bootstrap build) [probed]
2082   --with-build-jdk        path to JDK of same version as is being built[the
2083                           newly built JDK]
2084   --with-add-source-root  Deprecated. Option is kept for backwards
2085                           compatibility and is ignored
2086   --with-override-source-root
2087                           Deprecated. Option is kept for backwards
2088                           compatibility and is ignored
2089   --with-adds-and-overrides
2090                           Deprecated. Option is kept for backwards
2091                           compatibility and is ignored
2092   --with-override-langtools
2093                           Deprecated. Option is kept for backwards
2094                           compatibility and is ignored
2095   --with-override-corba   Deprecated. Option is kept for backwards
2096                           compatibility and is ignored
2097   --with-override-jaxp    Deprecated. Option is kept for backwards
2098                           compatibility and is ignored
2099   --with-override-jaxws   Deprecated. Option is kept for backwards
2100                           compatibility and is ignored
2101   --with-override-hotspot Deprecated. Option is kept for backwards
2102                           compatibility and is ignored
2103   --with-override-nashorn Deprecated. Option is kept for backwards
2104                           compatibility and is ignored
2105   --with-override-jdk     Deprecated. Option is kept for backwards
2106                           compatibility and is ignored
2107   --with-import-hotspot   import hotspot binaries from this jdk image or
2108                           hotspot build dist dir instead of building from
2109                           source
2110   --with-import-modules   import a set of prebuilt modules either as a zip
2111                           file or an exploded directory
2112   --with-toolchain-type   the toolchain type (or family) to use, use '--help'
2113                           to show possible values [platform dependent]
2114   --with-extra-cflags     extra flags to be used when compiling jdk c-files
2115   --with-extra-cxxflags   extra flags to be used when compiling jdk c++-files
2116   --with-extra-ldflags    extra flags to be used when linking jdk
2117   --with-toolchain-version
2118                           the version of the toolchain to look for, use
2119                           '--help' to show possible values [platform
2120                           dependent]
2121   --with-build-devkit     Devkit to use for the build platform toolchain
2122   --with-jtreg            Regression Test Harness [probed]
2123   --with-native-debug-symbols
2124                           set the native debug symbol configuration (none,
2125                           internal, external, zipped) [varying]
2126   --with-jvm-features     additional JVM features to enable (separated by
2127                           comma), use '--help' to show possible values [none]
2128   --with-jvm-interpreter  Deprecated. Option is kept for backwards
2129                           compatibility and is ignored
2130   --with-stdc++lib=<static>,<dynamic>,<default>
2131                           force linking of the C++ runtime on Linux to either
2132                           static or dynamic, default is static with dynamic as
2133                           fallback
2134   --with-msvcr-dll        path to microsoft C runtime dll (msvcr*.dll)
2135                           (Windows only) [probed]
2136   --with-msvcp-dll        path to microsoft C++ runtime dll (msvcp*.dll)
2137                           (Windows only) [probed]
2138   --with-x                use the X Window System
2139   --with-cups             specify prefix directory for the cups package
2140                           (expecting the headers under PATH/include)
2141   --with-cups-include     specify directory for the cups include files
2142   --with-freetype         specify prefix directory for the freetype package
2143                           (expecting the libraries under PATH/lib and the
2144                           headers under PATH/include)
2145   --with-freetype-include specify directory for the freetype include files
2146   --with-freetype-lib     specify directory for the freetype library
2147   --with-freetype-src     specify directory with freetype sources to
2148                           automatically build the library (experimental,
2149                           Windows-only)
2150   --with-alsa             specify prefix directory for the alsa package
2151                           (expecting the libraries under PATH/lib and the
2152                           headers under PATH/include)
2153   --with-alsa-include     specify directory for the alsa include files
2154   --with-alsa-lib         specify directory for the alsa library
2155   --with-libffi           specify prefix directory for the libffi package
2156                           (expecting the libraries under PATH/lib and the
2157                           headers under PATH/include)
2158   --with-libffi-include   specify directory for the libffi include files
2159   --with-libffi-lib       specify directory for the libffi library
2160   --with-libjpeg          use libjpeg from build system or OpenJDK source
2161                           (system, bundled) [bundled]
2162   --with-giflib           use giflib from build system or OpenJDK source
2163                           (system, bundled) [bundled]
2164   --with-libpng           use libpng from build system or OpenJDK source
2165                           (system, bundled) [bundled]
2166   --with-zlib             use zlib from build system or OpenJDK source
2167                           (system, bundled) [bundled]
2168   --with-lcms             use lcms2 from build system or OpenJDK source
2169                           (system, bundled) [bundled]
2170   --with-dxsdk            Deprecated. Option is kept for backwards
2171                           compatibility and is ignored
2172   --with-dxsdk-lib        Deprecated. Option is kept for backwards
2173                           compatibility and is ignored
2174   --with-dxsdk-include    Deprecated. Option is kept for backwards
2175                           compatibility and is ignored
2176   --with-num-cores        number of cores in the build system, e.g.
2177                           --with-num-cores=8 [probed]
2178   --with-memory-size      memory (in MB) available in the build system, e.g.
2179                           --with-memory-size=1024 [probed]
2180   --with-jobs             number of parallel jobs to let make run [calculated
2181                           based on cores and memory]
2182   --with-test-jobs        number of parallel tests jobs to run [based on build
2183                           jobs]
2184   --with-boot-jdk-jvmargs specify JVM arguments to be passed to all java
2185                           invocations of boot JDK, overriding the default
2186                           values, e.g --with-boot-jdk-jvmargs="-Xmx8G
2187                           -enableassertions"
2188   --with-sjavac-server-java
2189                           use this java binary for running the sjavac
2190                           background server [Boot JDK java]
2191   --with-ccache-dir       where to store ccache files [~/.ccache]
2192 
2193 Some influential environment variables:
2194   BASENAME    Override default value for BASENAME
2195   BASH        Override default value for BASH
2196   CAT         Override default value for CAT
2197   CHMOD       Override default value for CHMOD
2198   CMP         Override default value for CMP
2199   COMM        Override default value for COMM
2200   CP          Override default value for CP
2201   CUT         Override default value for CUT
2202   DATE        Override default value for DATE
2203   DIFF        Override default value for DIFF
2204   DIRNAME     Override default value for DIRNAME
2205   ECHO        Override default value for ECHO
2206   EXPR        Override default value for EXPR
2207   FILE        Override default value for FILE
2208   FIND        Override default value for FIND
2209   HEAD        Override default value for HEAD
2210   GUNZIP      Override default value for GUNZIP
2211   GZIP        Override default value for GZIP
2212   LN          Override default value for LN
2213   LS          Override default value for LS
2214   MKDIR       Override default value for MKDIR
2215   MKTEMP      Override default value for MKTEMP
2216   MV          Override default value for MV
2217   NAWK        Override default value for NAWK
2218   PRINTF      Override default value for PRINTF
2219   RM          Override default value for RM
2220   RMDIR       Override default value for RMDIR
2221   SH          Override default value for SH
2222   SORT        Override default value for SORT
2223   TAIL        Override default value for TAIL
2224   TAR         Override default value for TAR
2225   TEE         Override default value for TEE
2226   TOUCH       Override default value for TOUCH
2227   TR          Override default value for TR
2228   UNAME       Override default value for UNAME
2229   UNIQ        Override default value for UNIQ
2230   WC          Override default value for WC
2231   WHICH       Override default value for WHICH
2232   XARGS       Override default value for XARGS
2233   AWK         Override default value for AWK
2234   GREP        Override default value for GREP
2235   EGREP       Override default value for EGREP
2236   FGREP       Override default value for FGREP
2237   SED         Override default value for SED
2238   CYGPATH     Override default value for CYGPATH
2239   READLINK    Override default value for READLINK
2240   DF          Override default value for DF
2241   CPIO        Override default value for CPIO
2242   NICE        Override default value for NICE
2243   MAKE        Override default value for MAKE
2244   UNZIP       Override default value for UNZIP
2245   ZIP         Override default value for ZIP
2246   LDD         Override default value for LDD
2247   OTOOL       Override default value for OTOOL
2248   READELF     Override default value for READELF
2249   HG          Override default value for HG
2250   STAT        Override default value for STAT
2251   TIME        Override default value for TIME
2252   DTRACE      Override default value for DTRACE
2253   PATCH       Override default value for PATCH
2254   DSYMUTIL    Override default value for DSYMUTIL
2255   XATTR       Override default value for XATTR
2256   CODESIGN    Override default value for CODESIGN
2257   SETFILE     Override default value for SETFILE
2258   PKG_CONFIG  path to pkg-config utility
2259   JAVA        Override default value for JAVA
2260   JAVAC       Override default value for JAVAC
2261   JAVAH       Override default value for JAVAH
2262   JAR         Override default value for JAR
2263   JARSIGNER   Override default value for JARSIGNER
2264   CC          C compiler command
2265   CFLAGS      C compiler flags
2266   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
2267               nonstandard directory <lib dir>
2268   LIBS        libraries to pass to the linker, e.g. -l<library>
2269   CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
2270               you have headers in a nonstandard directory <include dir>
2271   CXX         C++ compiler command
2272   CXXFLAGS    C++ compiler flags
2273   CPP         C preprocessor
2274   CXXCPP      C++ preprocessor
2275   AS          Override default value for AS
2276   AR          Override default value for AR
2277   LIPO        Override default value for LIPO
2278   STRIP       Override default value for STRIP
2279   NM          Override default value for NM
2280   GNM         Override default value for GNM
2281   OBJCOPY     Override default value for OBJCOPY
2282   OBJDUMP     Override default value for OBJDUMP
2283   BUILD_CC    Override default value for BUILD_CC
2284   BUILD_CXX   Override default value for BUILD_CXX
2285   BUILD_NM    Override default value for BUILD_NM
2286   BUILD_AR    Override default value for BUILD_AR
2287   BUILD_OBJCOPY
2288               Override default value for BUILD_OBJCOPY
2289   BUILD_STRIP Override default value for BUILD_STRIP
2290   JTREGEXE    Override default value for JTREGEXE
2291   XMKMF       Path to xmkmf, Makefile generator for X Window System
2292   FREETYPE_CFLAGS
2293               C compiler flags for FREETYPE, overriding pkg-config
2294   FREETYPE_LIBS
2295               linker flags for FREETYPE, overriding pkg-config
2296   ALSA_CFLAGS C compiler flags for ALSA, overriding pkg-config
2297   ALSA_LIBS   linker flags for ALSA, overriding pkg-config
2298   LIBFFI_CFLAGS
2299               C compiler flags for LIBFFI, overriding pkg-config
2300   LIBFFI_LIBS linker flags for LIBFFI, overriding pkg-config
2301   PNG_CFLAGS  C compiler flags for PNG, overriding pkg-config
2302   PNG_LIBS    linker flags for PNG, overriding pkg-config
2303   LCMS_CFLAGS C compiler flags for LCMS, overriding pkg-config
2304   LCMS_LIBS   linker flags for LCMS, overriding pkg-config
2305   ICECC_CMD   Override default value for ICECC_CMD
2306   ICECC_CREATE_ENV
2307               Override default value for ICECC_CREATE_ENV
2308   ICECC_WRAPPER
2309               Override default value for ICECC_WRAPPER
2310   CCACHE      Override default value for CCACHE
2311 
2312 Use these variables to override the choices made by `configure' or to help
2313 it to find libraries and programs with nonstandard names/locations.
2314 
2315 Report bugs to <build-dev@openjdk.java.net>.
2316 OpenJDK home page: <http://openjdk.java.net>.
2317 _ACEOF
2318 ac_status=$?
2319 fi
2320 
2321 if test "$ac_init_help" = "recursive"; then
2322   # If there are subdirs, report their specific --help.
2323   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
2324     test -d "$ac_dir" ||
2325       { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } ||
2326       continue
2327     ac_builddir=.
2328 
2329 case "$ac_dir" in
2330 .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
2331 *)
2332   ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
2333   # A ".." for each directory in $ac_dir_suffix.
2334   ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
2335   case $ac_top_builddir_sub in
2336   "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
2337   *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
2338   esac ;;
2339 esac
2340 ac_abs_top_builddir=$ac_pwd
2341 ac_abs_builddir=$ac_pwd$ac_dir_suffix
2342 # for backward compatibility:
2343 ac_top_builddir=$ac_top_build_prefix
2344 
2345 case $srcdir in
2346   .)  # We are building in place.
2347     ac_srcdir=.
2348     ac_top_srcdir=$ac_top_builddir_sub
2349     ac_abs_top_srcdir=$ac_pwd ;;
2350   [\\/]* | ?:[\\/]* )  # Absolute name.
2351     ac_srcdir=$srcdir$ac_dir_suffix;
2352     ac_top_srcdir=$srcdir
2353     ac_abs_top_srcdir=$srcdir ;;
2354   *) # Relative name.
2355     ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
2356     ac_top_srcdir=$ac_top_build_prefix$srcdir
2357     ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
2358 esac
2359 ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
2360 
2361     cd "$ac_dir" || { ac_status=$?; continue; }
2362     # Check for guested configure.
2363     if test -f "$ac_srcdir/configure.gnu"; then
2364       echo &&
2365       $SHELL "$ac_srcdir/configure.gnu" --help=recursive
2366     elif test -f "$ac_srcdir/configure"; then
2367       echo &&
2368       $SHELL "$ac_srcdir/configure" --help=recursive
2369     else
2370       $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
2371     fi || ac_status=$?
2372     cd "$ac_pwd" || { ac_status=$?; break; }
2373   done
2374 fi
2375 
2376 test -n "$ac_init_help" && exit $ac_status
2377 if $ac_init_version; then
2378   cat <<\_ACEOF
2379 OpenJDK configure jdk9
2380 generated by GNU Autoconf 2.69
2381 
2382 Copyright (C) 2012 Free Software Foundation, Inc.
2383 This configure script is free software; the Free Software Foundation
2384 gives unlimited permission to copy, distribute and modify it.
2385 _ACEOF
2386   exit
2387 fi
2388 
2389 ## ------------------------ ##
2390 ## Autoconf initialization. ##
2391 ## ------------------------ ##
2392 
2393 # ac_fn_c_try_compile LINENO
2394 # --------------------------
2395 # Try to compile conftest.$ac_ext, and return whether this succeeded.
2396 ac_fn_c_try_compile ()
2397 {
2398   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2399   rm -f conftest.$ac_objext
2400   if { { ac_try="$ac_compile"
2401 case "(($ac_try" in
2402   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2403   *) ac_try_echo=$ac_try;;
2404 esac
2405 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2406 $as_echo "$ac_try_echo"; } >&5
2407   (eval "$ac_compile") 2>conftest.err
2408   ac_status=$?
2409   if test -s conftest.err; then
2410     grep -v '^ *+' conftest.err >conftest.er1
2411     cat conftest.er1 >&5
2412     mv -f conftest.er1 conftest.err
2413   fi
2414   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2415   test $ac_status = 0; } && {
2416          test -z "$ac_c_werror_flag" ||
2417          test ! -s conftest.err
2418        } && test -s conftest.$ac_objext; then :
2419   ac_retval=0
2420 else
2421   $as_echo "$as_me: failed program was:" >&5
2422 sed 's/^/| /' conftest.$ac_ext >&5
2423 
2424         ac_retval=1
2425 fi
2426   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2427   as_fn_set_status $ac_retval
2428 
2429 } # ac_fn_c_try_compile
2430 
2431 # ac_fn_cxx_try_compile LINENO
2432 # ----------------------------
2433 # Try to compile conftest.$ac_ext, and return whether this succeeded.
2434 ac_fn_cxx_try_compile ()
2435 {
2436   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2437   rm -f conftest.$ac_objext
2438   if { { ac_try="$ac_compile"
2439 case "(($ac_try" in
2440   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2441   *) ac_try_echo=$ac_try;;
2442 esac
2443 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2444 $as_echo "$ac_try_echo"; } >&5
2445   (eval "$ac_compile") 2>conftest.err
2446   ac_status=$?
2447   if test -s conftest.err; then
2448     grep -v '^ *+' conftest.err >conftest.er1
2449     cat conftest.er1 >&5
2450     mv -f conftest.er1 conftest.err
2451   fi
2452   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2453   test $ac_status = 0; } && {
2454          test -z "$ac_cxx_werror_flag" ||
2455          test ! -s conftest.err
2456        } && test -s conftest.$ac_objext; then :
2457   ac_retval=0
2458 else
2459   $as_echo "$as_me: failed program was:" >&5
2460 sed 's/^/| /' conftest.$ac_ext >&5
2461 
2462         ac_retval=1
2463 fi
2464   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2465   as_fn_set_status $ac_retval
2466 
2467 } # ac_fn_cxx_try_compile
2468 
2469 # ac_fn_c_try_cpp LINENO
2470 # ----------------------
2471 # Try to preprocess conftest.$ac_ext, and return whether this succeeded.
2472 ac_fn_c_try_cpp ()
2473 {
2474   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2475   if { { ac_try="$ac_cpp conftest.$ac_ext"
2476 case "(($ac_try" in
2477   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2478   *) ac_try_echo=$ac_try;;
2479 esac
2480 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2481 $as_echo "$ac_try_echo"; } >&5
2482   (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
2483   ac_status=$?
2484   if test -s conftest.err; then
2485     grep -v '^ *+' conftest.err >conftest.er1
2486     cat conftest.er1 >&5
2487     mv -f conftest.er1 conftest.err
2488   fi
2489   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2490   test $ac_status = 0; } > conftest.i && {
2491          test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
2492          test ! -s conftest.err
2493        }; then :
2494   ac_retval=0
2495 else
2496   $as_echo "$as_me: failed program was:" >&5
2497 sed 's/^/| /' conftest.$ac_ext >&5
2498 
2499     ac_retval=1
2500 fi
2501   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2502   as_fn_set_status $ac_retval
2503 
2504 } # ac_fn_c_try_cpp
2505 
2506 # ac_fn_cxx_try_cpp LINENO
2507 # ------------------------
2508 # Try to preprocess conftest.$ac_ext, and return whether this succeeded.
2509 ac_fn_cxx_try_cpp ()
2510 {
2511   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2512   if { { ac_try="$ac_cpp conftest.$ac_ext"
2513 case "(($ac_try" in
2514   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2515   *) ac_try_echo=$ac_try;;
2516 esac
2517 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2518 $as_echo "$ac_try_echo"; } >&5
2519   (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
2520   ac_status=$?
2521   if test -s conftest.err; then
2522     grep -v '^ *+' conftest.err >conftest.er1
2523     cat conftest.er1 >&5
2524     mv -f conftest.er1 conftest.err
2525   fi
2526   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2527   test $ac_status = 0; } > conftest.i && {
2528          test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
2529          test ! -s conftest.err
2530        }; then :
2531   ac_retval=0
2532 else
2533   $as_echo "$as_me: failed program was:" >&5
2534 sed 's/^/| /' conftest.$ac_ext >&5
2535 
2536     ac_retval=1
2537 fi
2538   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2539   as_fn_set_status $ac_retval
2540 
2541 } # ac_fn_cxx_try_cpp
2542 
2543 # ac_fn_c_try_link LINENO
2544 # -----------------------
2545 # Try to link conftest.$ac_ext, and return whether this succeeded.
2546 ac_fn_c_try_link ()
2547 {
2548   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2549   rm -f conftest.$ac_objext conftest$ac_exeext
2550   if { { ac_try="$ac_link"
2551 case "(($ac_try" in
2552   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2553   *) ac_try_echo=$ac_try;;
2554 esac
2555 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2556 $as_echo "$ac_try_echo"; } >&5
2557   (eval "$ac_link") 2>conftest.err
2558   ac_status=$?
2559   if test -s conftest.err; then
2560     grep -v '^ *+' conftest.err >conftest.er1
2561     cat conftest.er1 >&5
2562     mv -f conftest.er1 conftest.err
2563   fi
2564   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2565   test $ac_status = 0; } && {
2566          test -z "$ac_c_werror_flag" ||
2567          test ! -s conftest.err
2568        } && test -s conftest$ac_exeext && {
2569          test "$cross_compiling" = yes ||
2570          test -x conftest$ac_exeext
2571        }; then :
2572   ac_retval=0
2573 else
2574   $as_echo "$as_me: failed program was:" >&5
2575 sed 's/^/| /' conftest.$ac_ext >&5
2576 
2577         ac_retval=1
2578 fi
2579   # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
2580   # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
2581   # interfere with the next link command; also delete a directory that is
2582   # left behind by Apple's compiler.  We do this before executing the actions.
2583   rm -rf conftest.dSYM conftest_ipa8_conftest.oo
2584   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2585   as_fn_set_status $ac_retval
2586 
2587 } # ac_fn_c_try_link
2588 
2589 # ac_fn_cxx_check_header_mongrel LINENO HEADER VAR INCLUDES
2590 # ---------------------------------------------------------
2591 # Tests whether HEADER exists, giving a warning if it cannot be compiled using
2592 # the include files in INCLUDES and setting the cache variable VAR
2593 # accordingly.
2594 ac_fn_cxx_check_header_mongrel ()
2595 {
2596   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2597   if eval \${$3+:} false; then :
2598   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2599 $as_echo_n "checking for $2... " >&6; }
2600 if eval \${$3+:} false; then :
2601   $as_echo_n "(cached) " >&6
2602 fi
2603 eval ac_res=\$$3
2604                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2605 $as_echo "$ac_res" >&6; }
2606 else
2607   # Is the header compilable?
2608 { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
2609 $as_echo_n "checking $2 usability... " >&6; }
2610 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2611 /* end confdefs.h.  */
2612 $4
2613 #include <$2>
2614 _ACEOF
2615 if ac_fn_cxx_try_compile "$LINENO"; then :
2616   ac_header_compiler=yes
2617 else
2618   ac_header_compiler=no
2619 fi
2620 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2621 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
2622 $as_echo "$ac_header_compiler" >&6; }
2623 
2624 # Is the header present?
2625 { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
2626 $as_echo_n "checking $2 presence... " >&6; }
2627 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2628 /* end confdefs.h.  */
2629 #include <$2>
2630 _ACEOF
2631 if ac_fn_cxx_try_cpp "$LINENO"; then :
2632   ac_header_preproc=yes
2633 else
2634   ac_header_preproc=no
2635 fi
2636 rm -f conftest.err conftest.i conftest.$ac_ext
2637 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
2638 $as_echo "$ac_header_preproc" >&6; }
2639 
2640 # So?  What about this header?
2641 case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in #((
2642   yes:no: )
2643     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
2644 $as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
2645     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
2646 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
2647     ;;
2648   no:yes:* )
2649     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
2650 $as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
2651     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     check for missing prerequisite headers?" >&5
2652 $as_echo "$as_me: WARNING: $2:     check for missing prerequisite headers?" >&2;}
2653     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
2654 $as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
2655     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&5
2656 $as_echo "$as_me: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&2;}
2657     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
2658 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
2659 ( $as_echo "## ----------------------------------------- ##
2660 ## Report this to build-dev@openjdk.java.net ##
2661 ## ----------------------------------------- ##"
2662      ) | sed "s/^/$as_me: WARNING:     /" >&2
2663     ;;
2664 esac
2665   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2666 $as_echo_n "checking for $2... " >&6; }
2667 if eval \${$3+:} false; then :
2668   $as_echo_n "(cached) " >&6
2669 else
2670   eval "$3=\$ac_header_compiler"
2671 fi
2672 eval ac_res=\$$3
2673                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2674 $as_echo "$ac_res" >&6; }
2675 fi
2676   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2677 
2678 } # ac_fn_cxx_check_header_mongrel
2679 
2680 # ac_fn_cxx_try_run LINENO
2681 # ------------------------
2682 # Try to link conftest.$ac_ext, and return whether this succeeded. Assumes
2683 # that executables *can* be run.
2684 ac_fn_cxx_try_run ()
2685 {
2686   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2687   if { { ac_try="$ac_link"
2688 case "(($ac_try" in
2689   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2690   *) ac_try_echo=$ac_try;;
2691 esac
2692 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2693 $as_echo "$ac_try_echo"; } >&5
2694   (eval "$ac_link") 2>&5
2695   ac_status=$?
2696   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2697   test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'
2698   { { case "(($ac_try" in
2699   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2700   *) ac_try_echo=$ac_try;;
2701 esac
2702 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2703 $as_echo "$ac_try_echo"; } >&5
2704   (eval "$ac_try") 2>&5
2705   ac_status=$?
2706   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2707   test $ac_status = 0; }; }; then :
2708   ac_retval=0
2709 else
2710   $as_echo "$as_me: program exited with status $ac_status" >&5
2711        $as_echo "$as_me: failed program was:" >&5
2712 sed 's/^/| /' conftest.$ac_ext >&5
2713 
2714        ac_retval=$ac_status
2715 fi
2716   rm -rf conftest.dSYM conftest_ipa8_conftest.oo
2717   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2718   as_fn_set_status $ac_retval
2719 
2720 } # ac_fn_cxx_try_run
2721 
2722 # ac_fn_cxx_check_header_compile LINENO HEADER VAR INCLUDES
2723 # ---------------------------------------------------------
2724 # Tests whether HEADER exists and can be compiled using the include files in
2725 # INCLUDES, setting the cache variable VAR accordingly.
2726 ac_fn_cxx_check_header_compile ()
2727 {
2728   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2729   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2730 $as_echo_n "checking for $2... " >&6; }
2731 if eval \${$3+:} false; then :
2732   $as_echo_n "(cached) " >&6
2733 else
2734   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2735 /* end confdefs.h.  */
2736 $4
2737 #include <$2>
2738 _ACEOF
2739 if ac_fn_cxx_try_compile "$LINENO"; then :
2740   eval "$3=yes"
2741 else
2742   eval "$3=no"
2743 fi
2744 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2745 fi
2746 eval ac_res=\$$3
2747                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2748 $as_echo "$ac_res" >&6; }
2749   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2750 
2751 } # ac_fn_cxx_check_header_compile
2752 
2753 # ac_fn_cxx_compute_int LINENO EXPR VAR INCLUDES
2754 # ----------------------------------------------
2755 # Tries to find the compile-time value of EXPR in a program that includes
2756 # INCLUDES, setting VAR accordingly. Returns whether the value could be
2757 # computed
2758 ac_fn_cxx_compute_int ()
2759 {
2760   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2761   if test "$cross_compiling" = yes; then
2762     # Depending upon the size, compute the lo and hi bounds.
2763 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2764 /* end confdefs.h.  */
2765 $4
2766 int
2767 main ()
2768 {
2769 static int test_array [1 - 2 * !(($2) >= 0)];
2770 test_array [0] = 0;
2771 return test_array [0];
2772 
2773   ;
2774   return 0;
2775 }
2776 _ACEOF
2777 if ac_fn_cxx_try_compile "$LINENO"; then :
2778   ac_lo=0 ac_mid=0
2779   while :; do
2780     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2781 /* end confdefs.h.  */
2782 $4
2783 int
2784 main ()
2785 {
2786 static int test_array [1 - 2 * !(($2) <= $ac_mid)];
2787 test_array [0] = 0;
2788 return test_array [0];
2789 
2790   ;
2791   return 0;
2792 }
2793 _ACEOF
2794 if ac_fn_cxx_try_compile "$LINENO"; then :
2795   ac_hi=$ac_mid; break
2796 else
2797   as_fn_arith $ac_mid + 1 && ac_lo=$as_val
2798                         if test $ac_lo -le $ac_mid; then
2799                           ac_lo= ac_hi=
2800                           break
2801                         fi
2802                         as_fn_arith 2 '*' $ac_mid + 1 && ac_mid=$as_val
2803 fi
2804 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2805   done
2806 else
2807   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2808 /* end confdefs.h.  */
2809 $4
2810 int
2811 main ()
2812 {
2813 static int test_array [1 - 2 * !(($2) < 0)];
2814 test_array [0] = 0;
2815 return test_array [0];
2816 
2817   ;
2818   return 0;
2819 }
2820 _ACEOF
2821 if ac_fn_cxx_try_compile "$LINENO"; then :
2822   ac_hi=-1 ac_mid=-1
2823   while :; do
2824     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2825 /* end confdefs.h.  */
2826 $4
2827 int
2828 main ()
2829 {
2830 static int test_array [1 - 2 * !(($2) >= $ac_mid)];
2831 test_array [0] = 0;
2832 return test_array [0];
2833 
2834   ;
2835   return 0;
2836 }
2837 _ACEOF
2838 if ac_fn_cxx_try_compile "$LINENO"; then :
2839   ac_lo=$ac_mid; break
2840 else
2841   as_fn_arith '(' $ac_mid ')' - 1 && ac_hi=$as_val
2842                         if test $ac_mid -le $ac_hi; then
2843                           ac_lo= ac_hi=
2844                           break
2845                         fi
2846                         as_fn_arith 2 '*' $ac_mid && ac_mid=$as_val
2847 fi
2848 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2849   done
2850 else
2851   ac_lo= ac_hi=
2852 fi
2853 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2854 fi
2855 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2856 # Binary search between lo and hi bounds.
2857 while test "x$ac_lo" != "x$ac_hi"; do
2858   as_fn_arith '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo && ac_mid=$as_val
2859   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2860 /* end confdefs.h.  */
2861 $4
2862 int
2863 main ()
2864 {
2865 static int test_array [1 - 2 * !(($2) <= $ac_mid)];
2866 test_array [0] = 0;
2867 return test_array [0];
2868 
2869   ;
2870   return 0;
2871 }
2872 _ACEOF
2873 if ac_fn_cxx_try_compile "$LINENO"; then :
2874   ac_hi=$ac_mid
2875 else
2876   as_fn_arith '(' $ac_mid ')' + 1 && ac_lo=$as_val
2877 fi
2878 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2879 done
2880 case $ac_lo in #((
2881 ?*) eval "$3=\$ac_lo"; ac_retval=0 ;;
2882 '') ac_retval=1 ;;
2883 esac
2884   else
2885     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2886 /* end confdefs.h.  */
2887 $4
2888 static long int longval () { return $2; }
2889 static unsigned long int ulongval () { return $2; }
2890 #include <stdio.h>
2891 #include <stdlib.h>
2892 int
2893 main ()
2894 {
2895 
2896   FILE *f = fopen ("conftest.val", "w");
2897   if (! f)
2898     return 1;
2899   if (($2) < 0)
2900     {
2901       long int i = longval ();
2902       if (i != ($2))
2903         return 1;
2904       fprintf (f, "%ld", i);
2905     }
2906   else
2907     {
2908       unsigned long int i = ulongval ();
2909       if (i != ($2))
2910         return 1;
2911       fprintf (f, "%lu", i);
2912     }
2913   /* Do not output a trailing newline, as this causes \r\n confusion
2914      on some platforms.  */
2915   return ferror (f) || fclose (f) != 0;
2916 
2917   ;
2918   return 0;
2919 }
2920 _ACEOF
2921 if ac_fn_cxx_try_run "$LINENO"; then :
2922   echo >>conftest.val; read $3 <conftest.val; ac_retval=0
2923 else
2924   ac_retval=1
2925 fi
2926 rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
2927   conftest.$ac_objext conftest.beam conftest.$ac_ext
2928 rm -f conftest.val
2929 
2930   fi
2931   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2932   as_fn_set_status $ac_retval
2933 
2934 } # ac_fn_cxx_compute_int
2935 
2936 # ac_fn_cxx_try_link LINENO
2937 # -------------------------
2938 # Try to link conftest.$ac_ext, and return whether this succeeded.
2939 ac_fn_cxx_try_link ()
2940 {
2941   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2942   rm -f conftest.$ac_objext conftest$ac_exeext
2943   if { { ac_try="$ac_link"
2944 case "(($ac_try" in
2945   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2946   *) ac_try_echo=$ac_try;;
2947 esac
2948 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2949 $as_echo "$ac_try_echo"; } >&5
2950   (eval "$ac_link") 2>conftest.err
2951   ac_status=$?
2952   if test -s conftest.err; then
2953     grep -v '^ *+' conftest.err >conftest.er1
2954     cat conftest.er1 >&5
2955     mv -f conftest.er1 conftest.err
2956   fi
2957   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2958   test $ac_status = 0; } && {
2959          test -z "$ac_cxx_werror_flag" ||
2960          test ! -s conftest.err
2961        } && test -s conftest$ac_exeext && {
2962          test "$cross_compiling" = yes ||
2963          test -x conftest$ac_exeext
2964        }; then :
2965   ac_retval=0
2966 else
2967   $as_echo "$as_me: failed program was:" >&5
2968 sed 's/^/| /' conftest.$ac_ext >&5
2969 
2970         ac_retval=1
2971 fi
2972   # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
2973   # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
2974   # interfere with the next link command; also delete a directory that is
2975   # left behind by Apple's compiler.  We do this before executing the actions.
2976   rm -rf conftest.dSYM conftest_ipa8_conftest.oo
2977   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2978   as_fn_set_status $ac_retval
2979 
2980 } # ac_fn_cxx_try_link
2981 
2982 # ac_fn_cxx_check_func LINENO FUNC VAR
2983 # ------------------------------------
2984 # Tests whether FUNC exists, setting the cache variable VAR accordingly
2985 ac_fn_cxx_check_func ()
2986 {
2987   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2988   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2989 $as_echo_n "checking for $2... " >&6; }
2990 if eval \${$3+:} false; then :
2991   $as_echo_n "(cached) " >&6
2992 else
2993   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2994 /* end confdefs.h.  */
2995 /* Define $2 to an innocuous variant, in case <limits.h> declares $2.
2996    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
2997 #define $2 innocuous_$2
2998 
2999 /* System header to define __stub macros and hopefully few prototypes,
3000     which can conflict with char $2 (); below.
3001     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
3002     <limits.h> exists even on freestanding compilers.  */
3003 
3004 #ifdef __STDC__
3005 # include <limits.h>
3006 #else
3007 # include <assert.h>
3008 #endif
3009 
3010 #undef $2
3011 
3012 /* Override any GCC internal prototype to avoid an error.
3013    Use char because int might match the return type of a GCC
3014    builtin and then its argument prototype would still apply.  */
3015 #ifdef __cplusplus
3016 extern "C"
3017 #endif
3018 char $2 ();
3019 /* The GNU C library defines this for functions which it implements
3020     to always fail with ENOSYS.  Some functions are actually named
3021     something starting with __ and the normal name is an alias.  */
3022 #if defined __stub_$2 || defined __stub___$2
3023 choke me
3024 #endif
3025 
3026 int
3027 main ()
3028 {
3029 return $2 ();
3030   ;
3031   return 0;
3032 }
3033 _ACEOF
3034 if ac_fn_cxx_try_link "$LINENO"; then :
3035   eval "$3=yes"
3036 else
3037   eval "$3=no"
3038 fi
3039 rm -f core conftest.err conftest.$ac_objext \
3040     conftest$ac_exeext conftest.$ac_ext
3041 fi
3042 eval ac_res=\$$3
3043                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
3044 $as_echo "$ac_res" >&6; }
3045   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
3046 
3047 } # ac_fn_cxx_check_func
3048 
3049 # ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES
3050 # -------------------------------------------------------
3051 # Tests whether HEADER exists and can be compiled using the include files in
3052 # INCLUDES, setting the cache variable VAR accordingly.
3053 ac_fn_c_check_header_compile ()
3054 {
3055   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
3056   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
3057 $as_echo_n "checking for $2... " >&6; }
3058 if eval \${$3+:} false; then :
3059   $as_echo_n "(cached) " >&6
3060 else
3061   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3062 /* end confdefs.h.  */
3063 $4
3064 #include <$2>
3065 _ACEOF
3066 if ac_fn_c_try_compile "$LINENO"; then :
3067   eval "$3=yes"
3068 else
3069   eval "$3=no"
3070 fi
3071 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3072 fi
3073 eval ac_res=\$$3
3074                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
3075 $as_echo "$ac_res" >&6; }
3076   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
3077 
3078 } # ac_fn_c_check_header_compile
3079 cat >config.log <<_ACEOF
3080 This file contains any messages produced by compilers while
3081 running configure, to aid debugging if configure makes a mistake.
3082 
3083 It was created by OpenJDK $as_me jdk9, which was
3084 generated by GNU Autoconf 2.69.  Invocation command line was
3085 
3086   $ $0 $@
3087 
3088 _ACEOF
3089 exec 5>>config.log
3090 {
3091 cat <<_ASUNAME
3092 ## --------- ##
3093 ## Platform. ##
3094 ## --------- ##
3095 
3096 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
3097 uname -m = `(uname -m) 2>/dev/null || echo unknown`
3098 uname -r = `(uname -r) 2>/dev/null || echo unknown`
3099 uname -s = `(uname -s) 2>/dev/null || echo unknown`
3100 uname -v = `(uname -v) 2>/dev/null || echo unknown`
3101 
3102 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
3103 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
3104 
3105 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
3106 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
3107 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
3108 /usr/bin/hostinfo      = `(/usr/bin/hostinfo) 2>/dev/null      || echo unknown`
3109 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
3110 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
3111 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
3112 
3113 _ASUNAME
3114 
3115 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3116 for as_dir in $PATH
3117 do
3118   IFS=$as_save_IFS
3119   test -z "$as_dir" && as_dir=.
3120     $as_echo "PATH: $as_dir"
3121   done
3122 IFS=$as_save_IFS
3123 
3124 } >&5
3125 
3126 cat >&5 <<_ACEOF
3127 
3128 
3129 ## ----------- ##
3130 ## Core tests. ##
3131 ## ----------- ##
3132 
3133 _ACEOF
3134 
3135 
3136 # Keep a trace of the command line.
3137 # Strip out --no-create and --no-recursion so they do not pile up.
3138 # Strip out --silent because we don't want to record it for future runs.
3139 # Also quote any args containing shell meta-characters.
3140 # Make two passes to allow for proper duplicate-argument suppression.
3141 ac_configure_args=
3142 ac_configure_args0=
3143 ac_configure_args1=
3144 ac_must_keep_next=false
3145 for ac_pass in 1 2
3146 do
3147   for ac_arg
3148   do
3149     case $ac_arg in
3150     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
3151     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
3152     | -silent | --silent | --silen | --sile | --sil)
3153       continue ;;
3154     *\'*)
3155       ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
3156     esac
3157     case $ac_pass in
3158     1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;
3159     2)
3160       as_fn_append ac_configure_args1 " '$ac_arg'"
3161       if test $ac_must_keep_next = true; then
3162         ac_must_keep_next=false # Got value, back to normal.
3163       else
3164         case $ac_arg in
3165           *=* | --config-cache | -C | -disable-* | --disable-* \
3166           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
3167           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
3168           | -with-* | --with-* | -without-* | --without-* | --x)
3169             case "$ac_configure_args0 " in
3170               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
3171             esac
3172             ;;
3173           -* ) ac_must_keep_next=true ;;
3174         esac
3175       fi
3176       as_fn_append ac_configure_args " '$ac_arg'"
3177       ;;
3178     esac
3179   done
3180 done
3181 { ac_configure_args0=; unset ac_configure_args0;}
3182 { ac_configure_args1=; unset ac_configure_args1;}
3183 
3184 # When interrupted or exit'd, cleanup temporary files, and complete
3185 # config.log.  We remove comments because anyway the quotes in there
3186 # would cause problems or look ugly.
3187 # WARNING: Use '\'' to represent an apostrophe within the trap.
3188 # WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.
3189 trap 'exit_status=$?
3190   # Save into config.log some information that might help in debugging.
3191   {
3192     echo
3193 
3194     $as_echo "## ---------------- ##
3195 ## Cache variables. ##
3196 ## ---------------- ##"
3197     echo
3198     # The following way of writing the cache mishandles newlines in values,
3199 (
3200   for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do
3201     eval ac_val=\$$ac_var
3202     case $ac_val in #(
3203     *${as_nl}*)
3204       case $ac_var in #(
3205       *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
3206 $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
3207       esac
3208       case $ac_var in #(
3209       _ | IFS | as_nl) ;; #(
3210       BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
3211       *) { eval $ac_var=; unset $ac_var;} ;;
3212       esac ;;
3213     esac
3214   done
3215   (set) 2>&1 |
3216     case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #(
3217     *${as_nl}ac_space=\ *)
3218       sed -n \
3219         "s/'\''/'\''\\\\'\'''\''/g;
3220           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p"
3221       ;; #(
3222     *)
3223       sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
3224       ;;
3225     esac |
3226     sort
3227 )
3228     echo
3229 
3230     $as_echo "## ----------------- ##
3231 ## Output variables. ##
3232 ## ----------------- ##"
3233     echo
3234     for ac_var in $ac_subst_vars
3235     do
3236       eval ac_val=\$$ac_var
3237       case $ac_val in
3238       *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
3239       esac
3240       $as_echo "$ac_var='\''$ac_val'\''"
3241     done | sort
3242     echo
3243 
3244     if test -n "$ac_subst_files"; then
3245       $as_echo "## ------------------- ##
3246 ## File substitutions. ##
3247 ## ------------------- ##"
3248       echo
3249       for ac_var in $ac_subst_files
3250       do
3251         eval ac_val=\$$ac_var
3252         case $ac_val in
3253         *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
3254         esac
3255         $as_echo "$ac_var='\''$ac_val'\''"
3256       done | sort
3257       echo
3258     fi
3259 
3260     if test -s confdefs.h; then
3261       $as_echo "## ----------- ##
3262 ## confdefs.h. ##
3263 ## ----------- ##"
3264       echo
3265       cat confdefs.h
3266       echo
3267     fi
3268     test "$ac_signal" != 0 &&
3269       $as_echo "$as_me: caught signal $ac_signal"
3270     $as_echo "$as_me: exit $exit_status"
3271   } >&5
3272   rm -f core *.core core.conftest.* &&
3273     rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
3274     exit $exit_status
3275 ' 0
3276 for ac_signal in 1 2 13 15; do
3277   trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal
3278 done
3279 ac_signal=0
3280 
3281 # confdefs.h avoids OS command line length limits that DEFS can exceed.
3282 rm -f -r conftest* confdefs.h
3283 
3284 $as_echo "/* confdefs.h */" > confdefs.h
3285 
3286 # Predefined preprocessor variables.
3287 
3288 cat >>confdefs.h <<_ACEOF
3289 #define PACKAGE_NAME "$PACKAGE_NAME"
3290 _ACEOF
3291 
3292 cat >>confdefs.h <<_ACEOF
3293 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
3294 _ACEOF
3295 
3296 cat >>confdefs.h <<_ACEOF
3297 #define PACKAGE_VERSION "$PACKAGE_VERSION"
3298 _ACEOF
3299 
3300 cat >>confdefs.h <<_ACEOF
3301 #define PACKAGE_STRING "$PACKAGE_STRING"
3302 _ACEOF
3303 
3304 cat >>confdefs.h <<_ACEOF
3305 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
3306 _ACEOF
3307 
3308 cat >>confdefs.h <<_ACEOF
3309 #define PACKAGE_URL "$PACKAGE_URL"
3310 _ACEOF
3311 
3312 
3313 # Let the site file select an alternate cache file if it wants to.
3314 # Prefer an explicitly selected file to automatically selected ones.
3315 ac_site_file1=NONE
3316 ac_site_file2=NONE
3317 if test -n "$CONFIG_SITE"; then
3318   # We do not want a PATH search for config.site.
3319   case $CONFIG_SITE in #((
3320     -*)  ac_site_file1=./$CONFIG_SITE;;
3321     */*) ac_site_file1=$CONFIG_SITE;;
3322     *)   ac_site_file1=./$CONFIG_SITE;;
3323   esac
3324 elif test "x$prefix" != xNONE; then
3325   ac_site_file1=$prefix/share/config.site
3326   ac_site_file2=$prefix/etc/config.site
3327 else
3328   ac_site_file1=$ac_default_prefix/share/config.site
3329   ac_site_file2=$ac_default_prefix/etc/config.site
3330 fi
3331 for ac_site_file in "$ac_site_file1" "$ac_site_file2"
3332 do
3333   test "x$ac_site_file" = xNONE && continue
3334   if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then
3335     { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
3336 $as_echo "$as_me: loading site script $ac_site_file" >&6;}
3337     sed 's/^/| /' "$ac_site_file" >&5
3338     . "$ac_site_file" \
3339       || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3340 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3341 as_fn_error $? "failed to load site script $ac_site_file
3342 See \`config.log' for more details" "$LINENO" 5; }
3343   fi
3344 done
3345 
3346 if test -r "$cache_file"; then
3347   # Some versions of bash will fail to source /dev/null (special files
3348   # actually), so we avoid doing that.  DJGPP emulates it as a regular file.
3349   if test /dev/null != "$cache_file" && test -f "$cache_file"; then
3350     { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
3351 $as_echo "$as_me: loading cache $cache_file" >&6;}
3352     case $cache_file in
3353       [\\/]* | ?:[\\/]* ) . "$cache_file";;
3354       *)                      . "./$cache_file";;
3355     esac
3356   fi
3357 else
3358   { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
3359 $as_echo "$as_me: creating cache $cache_file" >&6;}
3360   >$cache_file
3361 fi
3362 
3363 # Check that the precious variables saved in the cache have kept the same
3364 # value.
3365 ac_cache_corrupted=false
3366 for ac_var in $ac_precious_vars; do
3367   eval ac_old_set=\$ac_cv_env_${ac_var}_set
3368   eval ac_new_set=\$ac_env_${ac_var}_set
3369   eval ac_old_val=\$ac_cv_env_${ac_var}_value
3370   eval ac_new_val=\$ac_env_${ac_var}_value
3371   case $ac_old_set,$ac_new_set in
3372     set,)
3373       { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
3374 $as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
3375       ac_cache_corrupted=: ;;
3376     ,set)
3377       { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5
3378 $as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
3379       ac_cache_corrupted=: ;;
3380     ,);;
3381     *)
3382       if test "x$ac_old_val" != "x$ac_new_val"; then
3383         # differences in whitespace do not lead to failure.
3384         ac_old_val_w=`echo x $ac_old_val`
3385         ac_new_val_w=`echo x $ac_new_val`
3386         if test "$ac_old_val_w" != "$ac_new_val_w"; then
3387           { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5
3388 $as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
3389           ac_cache_corrupted=:
3390         else
3391           { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
3392 $as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
3393           eval $ac_var=\$ac_old_val
3394         fi
3395         { $as_echo "$as_me:${as_lineno-$LINENO}:   former value:  \`$ac_old_val'" >&5
3396 $as_echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
3397         { $as_echo "$as_me:${as_lineno-$LINENO}:   current value: \`$ac_new_val'" >&5
3398 $as_echo "$as_me:   current value: \`$ac_new_val'" >&2;}
3399       fi;;
3400   esac
3401   # Pass precious variables to config.status.
3402   if test "$ac_new_set" = set; then
3403     case $ac_new_val in
3404     *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
3405     *) ac_arg=$ac_var=$ac_new_val ;;
3406     esac
3407     case " $ac_configure_args " in
3408       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
3409       *) as_fn_append ac_configure_args " '$ac_arg'" ;;
3410     esac
3411   fi
3412 done
3413 if $ac_cache_corrupted; then
3414   { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3415 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3416   { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
3417 $as_echo "$as_me: error: changes in the environment can compromise the build" >&2;}
3418   as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5
3419 fi
3420 ## -------------------- ##
3421 ## Main body of script. ##
3422 ## -------------------- ##
3423 
3424 ac_ext=c
3425 ac_cpp='$CPP $CPPFLAGS'
3426 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3427 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3428 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3429 
3430 
3431 
3432 ac_aux_dir=
3433 for ac_dir in $TOPDIR/common/autoconf/build-aux "$srcdir"/$TOPDIR/common/autoconf/build-aux; do
3434   if test -f "$ac_dir/install-sh"; then
3435     ac_aux_dir=$ac_dir
3436     ac_install_sh="$ac_aux_dir/install-sh -c"
3437     break
3438   elif test -f "$ac_dir/install.sh"; then
3439     ac_aux_dir=$ac_dir
3440     ac_install_sh="$ac_aux_dir/install.sh -c"
3441     break
3442   elif test -f "$ac_dir/shtool"; then
3443     ac_aux_dir=$ac_dir
3444     ac_install_sh="$ac_aux_dir/shtool install -c"
3445     break
3446   fi
3447 done
3448 if test -z "$ac_aux_dir"; then
3449   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
3450 fi
3451 
3452 # These three variables are undocumented and unsupported,
3453 # and are intended to be withdrawn in a future Autoconf release.
3454 # They can cause serious problems if a builder's source tree is in a directory
3455 # whose full name contains unusual characters.
3456 ac_config_guess="$SHELL $ac_aux_dir/config.guess"  # Please don't use this var.
3457 ac_config_sub="$SHELL $ac_aux_dir/config.sub"  # Please don't use this var.
3458 ac_configure="$SHELL $ac_aux_dir/configure"  # Please don't use this var.
3459 
3460 
3461 # pkg.m4 - Macros to locate and utilise pkg-config.            -*- Autoconf -*-
3462 
3463 #
3464 # Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
3465 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3466 #
3467 # This code is free software; you can redistribute it and/or modify it
3468 # under the terms of the GNU General Public License version 2 only, as
3469 # published by the Free Software Foundation.  Oracle designates this
3470 # particular file as subject to the "Classpath" exception as provided
3471 # by Oracle in the LICENSE file that accompanied this code.
3472 #
3473 # This code is distributed in the hope that it will be useful, but WITHOUT
3474 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3475 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3476 # version 2 for more details (a copy is included in the LICENSE file that
3477 # accompanied this code).
3478 #
3479 # You should have received a copy of the GNU General Public License version
3480 # 2 along with this work; if not, write to the Free Software Foundation,
3481 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3482 #
3483 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3484 # or visit www.oracle.com if you need additional information or have any
3485 # questions.
3486 #
3487 
3488 #
3489 # Copyright © 2004 Scott James Remnant <scott@netsplit.com>.
3490 #
3491 # This program is free software; you can redistribute it and/or modify
3492 # it under the terms of the GNU General Public License as published by
3493 # the Free Software Foundation; either version 2 of the License, or
3494 # (at your option) any later version.
3495 #
3496 # This program is distributed in the hope that it will be useful, but
3497 # WITHOUT ANY WARRANTY; without even the implied warranty of
3498 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
3499 # General Public License for more details.
3500 #
3501 # You should have received a copy of the GNU General Public License
3502 # along with this program; if not, write to the Free Software
3503 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
3504 #
3505 # As a special exception to the GNU General Public License, if you
3506 # distribute this file as part of a program that contains a
3507 # configuration script generated by Autoconf, you may include it under
3508 # the same distribution terms that you use for the rest of that program.
3509 
3510 # PKG_PROG_PKG_CONFIG([MIN-VERSION])
3511 # ----------------------------------
3512 # PKG_PROG_PKG_CONFIG
3513 
3514 # PKG_CHECK_EXISTS(MODULES, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
3515 #
3516 # Check to see whether a particular set of modules exists.  Similar
3517 # to PKG_CHECK_MODULES(), but does not set variables or print errors.
3518 #
3519 #
3520 # Similar to PKG_CHECK_MODULES, make sure that the first instance of
3521 # this or PKG_CHECK_MODULES is called, or make sure to call
3522 # PKG_CHECK_EXISTS manually
3523 # --------------------------------------------------------------
3524 
3525 
3526 
3527 # _PKG_CONFIG([VARIABLE], [COMMAND], [MODULES])
3528 # ---------------------------------------------
3529 # _PKG_CONFIG
3530 
3531 # _PKG_SHORT_ERRORS_SUPPORTED
3532 # -----------------------------
3533 # _PKG_SHORT_ERRORS_SUPPORTED
3534 
3535 
3536 # PKG_CHECK_MODULES(VARIABLE-PREFIX, MODULES, [ACTION-IF-FOUND],
3537 # [ACTION-IF-NOT-FOUND])
3538 #
3539 #
3540 # Note that if there is a possibility the first call to
3541 # PKG_CHECK_MODULES might not happen, you should be sure to include an
3542 # explicit call to PKG_PROG_PKG_CONFIG in your configure.ac
3543 #
3544 #
3545 # --------------------------------------------------------------
3546 # PKG_CHECK_MODULES
3547 
3548 
3549 # Include these first...
3550 #
3551 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
3552 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3553 #
3554 # This code is free software; you can redistribute it and/or modify it
3555 # under the terms of the GNU General Public License version 2 only, as
3556 # published by the Free Software Foundation.  Oracle designates this
3557 # particular file as subject to the "Classpath" exception as provided
3558 # by Oracle in the LICENSE file that accompanied this code.
3559 #
3560 # This code is distributed in the hope that it will be useful, but WITHOUT
3561 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3562 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3563 # version 2 for more details (a copy is included in the LICENSE file that
3564 # accompanied this code).
3565 #
3566 # You should have received a copy of the GNU General Public License version
3567 # 2 along with this work; if not, write to the Free Software Foundation,
3568 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3569 #
3570 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3571 # or visit www.oracle.com if you need additional information or have any
3572 # questions.
3573 #
3574 
3575 # Create a function/macro that takes a series of named arguments. The call is
3576 # similar to AC_DEFUN, but the setup of the function looks like this:
3577 # BASIC_DEFUN_NAMED([MYFUNC], [FOO *BAR], [$@], [
3578 # ... do something
3579 #   AC_MSG_NOTICE([Value of BAR is ARG_BAR])
3580 # ])
3581 # A star (*) in front of a named argument means that it is required and it's
3582 # presence will be verified. To pass e.g. the first value as a normal indexed
3583 # argument, use [m4_shift($@)] as the third argument instead of [$@]. These
3584 # arguments are referenced in the function by their name prefixed by ARG_, e.g.
3585 # "ARG_FOO".
3586 #
3587 # The generated function can be called like this:
3588 # MYFUNC(FOO: [foo-val],
3589 #     BAR: [
3590 #         $ECHO hello world
3591 #     ])
3592 # Note that the argument value must start on the same line as the argument name.
3593 #
3594 # Argument 1: Name of the function to define
3595 # Argument 2: List of legal named arguments, with a * prefix for required arguments
3596 # Argument 3: Argument array to treat as named, typically $@
3597 # Argument 4: The main function body
3598 
3599 
3600 # Test if $1 is a valid argument to $3 (often is $JAVA passed as $3)
3601 # If so, then append $1 to $2 \
3602 # Also set JVM_ARG_OK to true/false depending on outcome.
3603 
3604 
3605 # Appends a string to a path variable, only adding the : when needed.
3606 
3607 
3608 # Prepends a string to a path variable, only adding the : when needed.
3609 
3610 
3611 # This will make sure the given variable points to a full and proper
3612 # path. This means:
3613 # 1) There will be no spaces in the path. On unix platforms,
3614 #    spaces in the path will result in an error. On Windows,
3615 #    the path will be rewritten using short-style to be space-free.
3616 # 2) The path will be absolute, and it will be in unix-style (on
3617 #     cygwin).
3618 # $1: The name of the variable to fix
3619 
3620 
3621 # This will make sure the given variable points to a executable
3622 # with a full and proper path. This means:
3623 # 1) There will be no spaces in the path. On unix platforms,
3624 #    spaces in the path will result in an error. On Windows,
3625 #    the path will be rewritten using short-style to be space-free.
3626 # 2) The path will be absolute, and it will be in unix-style (on
3627 #     cygwin).
3628 # Any arguments given to the executable is preserved.
3629 # If the input variable does not have a directory specification, then
3630 # it need to be in the PATH.
3631 # $1: The name of the variable to fix
3632 
3633 
3634 
3635 
3636 # Register a --with argument but mark it as deprecated
3637 # $1: The name of the with argument to deprecate, not including --with-
3638 
3639 
3640 # Register a --enable argument but mark it as deprecated
3641 # $1: The name of the with argument to deprecate, not including --enable-
3642 # $2: The name of the argument to deprecate, in shell variable style (i.e. with _ instead of -)
3643 # $3: Messages to user.
3644 
3645 
3646 
3647 
3648 # Test that variable $1 denoting a program is not empty. If empty, exit with an error.
3649 # $1: variable to check
3650 
3651 
3652 # Check that there are no unprocessed overridden variables left.
3653 # If so, they are an incorrect argument and we will exit with an error.
3654 
3655 
3656 # Setup a tool for the given variable. If correctly specified by the user,
3657 # use that value, otherwise search for the tool using the supplied code snippet.
3658 # $1: variable to set
3659 # $2: code snippet to call to look for the tool
3660 # $3: code snippet to call if variable was used to find tool
3661 
3662 
3663 # Call BASIC_SETUP_TOOL with AC_PATH_PROGS to locate the tool
3664 # $1: variable to set
3665 # $2: executable name (or list of names) to look for
3666 
3667 
3668 # Call BASIC_SETUP_TOOL with AC_CHECK_TOOLS to locate the tool
3669 # $1: variable to set
3670 # $2: executable name (or list of names) to look for
3671 
3672 
3673 # Like BASIC_PATH_PROGS but fails if no tool was found.
3674 # $1: variable to set
3675 # $2: executable name (or list of names) to look for
3676 
3677 
3678 # Like BASIC_SETUP_TOOL but fails if no tool was found.
3679 # $1: variable to set
3680 # $2: autoconf macro to call to look for the special tool
3681 
3682 
3683 # Setup the most fundamental tools that relies on not much else to set up,
3684 # but is used by much of the early bootstrap code.
3685 
3686 
3687 # Setup basic configuration paths, and platform-specific stuff related to PATHs.
3688 
3689 
3690 # Evaluates platform specific overrides for devkit variables.
3691 # $1: Name of variable
3692 
3693 
3694 
3695 
3696 
3697 
3698 #%%% Simple tools %%%
3699 
3700 # Check if we have found a usable version of make
3701 # $1: the path to a potential make binary (or empty)
3702 # $2: the description on how we found this
3703 
3704 
3705 
3706 
3707 # Goes looking for a usable version of GNU make.
3708 
3709 
3710 
3711 
3712 
3713 
3714 
3715 
3716 # Check if build directory is on local disk. If not possible to determine,
3717 # we prefer to claim it's local.
3718 # Argument 1: directory to test
3719 # Argument 2: what to do if it is on local disk
3720 # Argument 3: what to do otherwise (remote disk or failure)
3721 
3722 
3723 # Check that source files have basic read permissions set. This might
3724 # not be the case in cygwin in certain conditions.
3725 
3726 
3727 
3728 
3729 # Check for support for specific options in bash
3730 
3731 
3732 ################################################################################
3733 #
3734 # Default make target
3735 #
3736 
3737 
3738 # Code to run after AC_OUTPUT
3739 
3740 
3741 #
3742 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
3743 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3744 #
3745 # This code is free software; you can redistribute it and/or modify it
3746 # under the terms of the GNU General Public License version 2 only, as
3747 # published by the Free Software Foundation.  Oracle designates this
3748 # particular file as subject to the "Classpath" exception as provided
3749 # by Oracle in the LICENSE file that accompanied this code.
3750 #
3751 # This code is distributed in the hope that it will be useful, but WITHOUT
3752 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3753 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3754 # version 2 for more details (a copy is included in the LICENSE file that
3755 # accompanied this code).
3756 #
3757 # You should have received a copy of the GNU General Public License version
3758 # 2 along with this work; if not, write to the Free Software Foundation,
3759 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3760 #
3761 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3762 # or visit www.oracle.com if you need additional information or have any
3763 # questions.
3764 #
3765 
3766 
3767 
3768 
3769 
3770 # Helper function which possibly converts a path using DOS-style short mode.
3771 # If so, the updated path is stored in $new_path.
3772 # $1: The path to check
3773 
3774 
3775 # Helper function which possibly converts a path using DOS-style short mode.
3776 # If so, the updated path is stored in $new_path.
3777 # $1: The path to check
3778 
3779 
3780 # FIXME: The BASIC_FIXUP_*_CYGWIN/MSYS is most likely too convoluted
3781 # and could probably be heavily simplified. However, all changes in this
3782 # area tend to need lot of testing in different scenarios, and in lack of
3783 # proper unit testing, cleaning this up has not been deemed worth the effort
3784 # at the moment.
3785 
3786 
3787 
3788 
3789 
3790 
3791 
3792 
3793 
3794 # Setup basic configuration paths, and platform-specific stuff related to PATHs.
3795 
3796 
3797 
3798 
3799 # ... then the rest
3800 #
3801 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
3802 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3803 #
3804 # This code is free software; you can redistribute it and/or modify it
3805 # under the terms of the GNU General Public License version 2 only, as
3806 # published by the Free Software Foundation.  Oracle designates this
3807 # particular file as subject to the "Classpath" exception as provided
3808 # by Oracle in the LICENSE file that accompanied this code.
3809 #
3810 # This code is distributed in the hope that it will be useful, but WITHOUT
3811 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3812 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3813 # version 2 for more details (a copy is included in the LICENSE file that
3814 # accompanied this code).
3815 #
3816 # You should have received a copy of the GNU General Public License version
3817 # 2 along with this work; if not, write to the Free Software Foundation,
3818 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3819 #
3820 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3821 # or visit www.oracle.com if you need additional information or have any
3822 # questions.
3823 #
3824 
3825 ########################################################################
3826 # This file handles detection of the Boot JDK. The Boot JDK detection
3827 # process has been developed as a response to solve a complex real-world
3828 # problem. Initially, it was simple, but it has grown as platform after
3829 # platform, idiosyncracy after idiosyncracy has been supported.
3830 #
3831 # The basic idea is this:
3832 # 1) You need an acceptable *) JDK to use as a Boot JDK
3833 # 2) There are several ways to locate a JDK, that are mostly platform
3834 #    dependent **)
3835 # 3) You can have multiple JDKs installed
3836 # 4) If possible, configure should try to dig out an acceptable JDK
3837 #    automatically, without having to resort to command-line options
3838 #
3839 # *)  acceptable means e.g. JDK7 for building JDK8, a complete JDK (with
3840 #     javac) and not a JRE, etc.
3841 #
3842 # **) On Windows we typically use a well-known path.
3843 #     On MacOSX we typically use the tool java_home.
3844 #     On Linux we typically find javac in the $PATH, and then follow a
3845 #     chain of symlinks that often ends up in a real JDK.
3846 #
3847 # This leads to the code where we check in different ways to locate a
3848 # JDK, and if one is found, check if it is acceptable. If not, we print
3849 # our reasons for rejecting it (useful when debugging non-working
3850 # configure situations) and continue checking the next one.
3851 ########################################################################
3852 
3853 # Execute the check given as argument, and verify the result
3854 # If the Boot JDK was previously found, do nothing
3855 # $1 A command line (typically autoconf macro) to execute
3856 
3857 
3858 # Test: Is bootjdk explicitely set by command line arguments?
3859 
3860 
3861 # Test: Is $JAVA_HOME set?
3862 
3863 
3864 # Test: Is there a java or javac in the PATH, which is a symlink to the JDK?
3865 
3866 
3867 # Test: Is there a /usr/libexec/java_home? (Typically on MacOSX)
3868 # $1: Argument to the java_home binary (optional)
3869 
3870 
3871 # Test: On MacOS X, can we find a boot jdk using /usr/libexec/java_home?
3872 
3873 
3874 # Look for a jdk in the given path. If there are multiple, try to select the newest.
3875 # If found, set BOOT_JDK and BOOT_JDK_FOUND.
3876 # $1 = Path to directory containing jdk installations.
3877 # $2 = String to append to the found JDK directory to get the proper JDK home
3878 
3879 
3880 # Call BOOTJDK_FIND_BEST_JDK_IN_DIRECTORY, but use the given
3881 # environmental variable as base for where to look.
3882 # $1 Name of an environmal variable, assumed to point to the Program Files directory.
3883 
3884 
3885 # Test: Is there a JDK installed in default, well-known locations?
3886 
3887 
3888 # Check that a command-line tool in the Boot JDK is correct
3889 # $1 = name of variable to assign
3890 # $2 = name of binary
3891 
3892 
3893 ###############################################################################
3894 #
3895 # We need a Boot JDK to bootstrap the build.
3896 #
3897 
3898 
3899 
3900 
3901 
3902 # BUILD_JDK: the location of the latest JDK that can run
3903 #   on the host system and supports the target class file version
3904 #   generated in this JDK build.  This variable should only be
3905 #   used after the launchers are built.
3906 #
3907 
3908 # Execute the check given as argument, and verify the result.
3909 # If the JDK was previously found, do nothing.
3910 # $1 A command line (typically autoconf macro) to execute
3911 
3912 
3913 # By default the BUILD_JDK is the JDK_OUTPUTDIR.  If the target architecture
3914 # is different than the host system doing the build (e.g. cross-compilation),
3915 # a special BUILD_JDK is built as part of the build process.  An external
3916 # prebuilt BUILD_JDK can also be supplied.
3917 
3918 
3919 #
3920 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
3921 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3922 #
3923 # This code is free software; you can redistribute it and/or modify it
3924 # under the terms of the GNU General Public License version 2 only, as
3925 # published by the Free Software Foundation.  Oracle designates this
3926 # particular file as subject to the "Classpath" exception as provided
3927 # by Oracle in the LICENSE file that accompanied this code.
3928 #
3929 # This code is distributed in the hope that it will be useful, but WITHOUT
3930 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3931 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3932 # version 2 for more details (a copy is included in the LICENSE file that
3933 # accompanied this code).
3934 #
3935 # You should have received a copy of the GNU General Public License version
3936 # 2 along with this work; if not, write to the Free Software Foundation,
3937 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3938 #
3939 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3940 # or visit www.oracle.com if you need additional information or have any
3941 # questions.
3942 #
3943 
3944 
3945 
3946 
3947 
3948 
3949 
3950 
3951 
3952 
3953 
3954 
3955 
3956 
3957 
3958 
3959 
3960 ################################################################################
3961 #
3962 # Runs icecc-create-env once and prints the error if it fails
3963 #
3964 # $1: arguments to icecc-create-env
3965 # $2: log file
3966 #
3967 
3968 
3969 ################################################################################
3970 #
3971 # Optionally enable distributed compilation of native code using icecc/icecream
3972 #
3973 
3974 
3975 
3976 
3977 
3978 
3979 
3980 #
3981 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
3982 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3983 #
3984 # This code is free software; you can redistribute it and/or modify it
3985 # under the terms of the GNU General Public License version 2 only, as
3986 # published by the Free Software Foundation.  Oracle designates this
3987 # particular file as subject to the "Classpath" exception as provided
3988 # by Oracle in the LICENSE file that accompanied this code.
3989 #
3990 # This code is distributed in the hope that it will be useful, but WITHOUT
3991 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3992 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3993 # version 2 for more details (a copy is included in the LICENSE file that
3994 # accompanied this code).
3995 #
3996 # You should have received a copy of the GNU General Public License version
3997 # 2 along with this work; if not, write to the Free Software Foundation,
3998 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3999 #
4000 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4001 # or visit www.oracle.com if you need additional information or have any
4002 # questions.
4003 #
4004 
4005 # Reset the global CFLAGS/LDFLAGS variables and initialize them with the
4006 # corresponding configure arguments instead
4007 
4008 
4009 # Setup the sysroot flags and add them to global CFLAGS and LDFLAGS so
4010 # that configure can use them while detecting compilers.
4011 # TOOLCHAIN_TYPE is available here.
4012 # Param 1 - Optional prefix to all variables. (e.g BUILD_)
4013 
4014 
4015 
4016 
4017 
4018 
4019 # Documentation on common flags used for solstudio in HIGHEST.
4020 #
4021 # WARNING: Use of OPTIMIZATION_LEVEL=HIGHEST in your Makefile needs to be
4022 #          done with care, there are some assumptions below that need to
4023 #          be understood about the use of pointers, and IEEE behavior.
4024 #
4025 # -fns: Use non-standard floating point mode (not IEEE 754)
4026 # -fsimple: Do some simplification of floating point arithmetic (not IEEE 754)
4027 # -fsingle: Use single precision floating point with 'float'
4028 # -xalias_level=basic: Assume memory references via basic pointer types do not alias
4029 #   (Source with excessing pointer casting and data access with mixed
4030 #    pointer types are not recommended)
4031 # -xbuiltin=%all: Use intrinsic or inline versions for math/std functions
4032 #   (If you expect perfect errno behavior, do not use this)
4033 # -xdepend: Loop data dependency optimizations (need -xO3 or higher)
4034 # -xrestrict: Pointer parameters to functions do not overlap
4035 #   (Similar to -xalias_level=basic usage, but less obvious sometimes.
4036 #    If you pass in multiple pointers to the same data, do not use this)
4037 # -xlibmil: Inline some library routines
4038 #   (If you expect perfect errno behavior, do not use this)
4039 # -xlibmopt: Use optimized math routines (CURRENTLY DISABLED)
4040 #   (If you expect perfect errno behavior, do not use this)
4041 #  Can cause undefined external on Solaris 8 X86 on __sincos, removing for now
4042 
4043     # FIXME: this will never happen since sparc != sparcv9, ie 32 bit, which we don't build anymore.
4044     # Bug?
4045     #if test "x$OPENJDK_TARGET_CPU" = xsparc; then
4046     #  CFLAGS_JDK="${CFLAGS_JDK} -xmemalign=4s"
4047     #  CXXFLAGS_JDK="${CXXFLAGS_JDK} -xmemalign=4s"
4048     #fi
4049 
4050 
4051 
4052 
4053 
4054 
4055 ################################################################################
4056 # $1 - Either BUILD or TARGET to pick the correct OS/CPU variables to check
4057 #      conditionals against.
4058 # $2 - Optional prefix for each variable defined.
4059 
4060 
4061 # FLAGS_C_COMPILER_CHECK_ARGUMENTS(ARGUMENT: [ARGUMENT], IF_TRUE: [RUN-IF-TRUE],
4062 #                                  IF_FALSE: [RUN-IF-FALSE])
4063 # ------------------------------------------------------------
4064 # Check that the C compiler supports an argument
4065 
4066 
4067 
4068 
4069 # FLAGS_CXX_COMPILER_CHECK_ARGUMENTS(ARGUMENT: [ARGUMENT], IF_TRUE: [RUN-IF-TRUE],
4070 #                                    IF_FALSE: [RUN-IF-FALSE])
4071 # ------------------------------------------------------------
4072 # Check that the C++ compiler supports an argument
4073 
4074 
4075 
4076 
4077 # FLAGS_COMPILER_CHECK_ARGUMENTS(ARGUMENT: [ARGUMENT], IF_TRUE: [RUN-IF-TRUE],
4078 #                                IF_FALSE: [RUN-IF-FALSE])
4079 # ------------------------------------------------------------
4080 # Check that the C and C++ compilers support an argument
4081 
4082 
4083 
4084 
4085 # FLAGS_LINKER_CHECK_ARGUMENTS(ARGUMENT: [ARGUMENT], IF_TRUE: [RUN-IF-TRUE],
4086 #                                   IF_FALSE: [RUN-IF-FALSE])
4087 # ------------------------------------------------------------
4088 # Check that the linker support an argument
4089 
4090 
4091 
4092 
4093 
4094 
4095 
4096 
4097 #
4098 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
4099 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4100 #
4101 # This code is free software; you can redistribute it and/or modify it
4102 # under the terms of the GNU General Public License version 2 only, as
4103 # published by the Free Software Foundation.  Oracle designates this
4104 # particular file as subject to the "Classpath" exception as provided
4105 # by Oracle in the LICENSE file that accompanied this code.
4106 #
4107 # This code is distributed in the hope that it will be useful, but WITHOUT
4108 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4109 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4110 # version 2 for more details (a copy is included in the LICENSE file that
4111 # accompanied this code).
4112 #
4113 # You should have received a copy of the GNU General Public License version
4114 # 2 along with this work; if not, write to the Free Software Foundation,
4115 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4116 #
4117 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4118 # or visit www.oracle.com if you need additional information or have any
4119 # questions.
4120 #
4121 
4122 
4123 
4124 
4125 
4126 cygwin_help() {
4127   case $1 in
4128     unzip)
4129       PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P unzip )"
4130       HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
4131       ;;
4132     zip)
4133       PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P zip )"
4134       HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
4135       ;;
4136     make)
4137       PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P make )"
4138       HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
4139       ;;
4140     freetype)
4141       HELP_MSG="
4142 The freetype library can now be build during the configure process.
4143 Download the freetype sources and unpack them into an arbitrary directory:
4144 
4145 wget http://download.savannah.gnu.org/releases/freetype/freetype-2.5.3.tar.gz
4146 tar -xzf freetype-2.5.3.tar.gz
4147 
4148 Then run configure with '--with-freetype-src=<freetype_src>'. This will
4149 automatically build the freetype library into '<freetype_src>/lib64' for 64-bit
4150 builds or into '<freetype_src>/lib32' for 32-bit builds.
4151 Afterwards you can always use '--with-freetype-include=<freetype_src>/include'
4152 and '--with-freetype-lib=<freetype_src>/lib32|64' for other builds.
4153 
4154 Alternatively you can unpack the sources like this to use the default directory:
4155 
4156 tar --one-top-level=$HOME/freetype --strip-components=1 -xzf freetype-2.5.3.tar.gz"
4157       ;;
4158   esac
4159 }
4160 
4161 msys_help() {
4162   PKGHANDLER_COMMAND=""
4163 }
4164 
4165 apt_help() {
4166   case $1 in
4167     reduced)
4168       PKGHANDLER_COMMAND="sudo apt-get install gcc-multilib g++-multilib" ;;
4169     devkit)
4170       PKGHANDLER_COMMAND="sudo apt-get install build-essential" ;;
4171     openjdk)
4172       PKGHANDLER_COMMAND="sudo apt-get install openjdk-8-jdk" ;;
4173     alsa)
4174       PKGHANDLER_COMMAND="sudo apt-get install libasound2-dev" ;;
4175     cups)
4176       PKGHANDLER_COMMAND="sudo apt-get install libcups2-dev" ;;
4177     freetype)
4178       PKGHANDLER_COMMAND="sudo apt-get install libfreetype6-dev" ;;
4179     ffi)
4180       PKGHANDLER_COMMAND="sudo apt-get install libffi-dev" ;;
4181     x11)
4182       PKGHANDLER_COMMAND="sudo apt-get install libX11-dev libxext-dev libxrender-dev libxtst-dev libxt-dev" ;;
4183     ccache)
4184       PKGHANDLER_COMMAND="sudo apt-get install ccache" ;;
4185     dtrace)
4186       PKGHANDLER_COMMAND="sudo apt-get install systemtap-sdt-dev" ;;
4187   esac
4188 }
4189 
4190 yum_help() {
4191   case $1 in
4192     devkit)
4193       PKGHANDLER_COMMAND="sudo yum groupinstall \"Development Tools\"" ;;
4194     openjdk)
4195       PKGHANDLER_COMMAND="sudo yum install java-1.8.0-openjdk-devel" ;;
4196     alsa)
4197       PKGHANDLER_COMMAND="sudo yum install alsa-lib-devel" ;;
4198     cups)
4199       PKGHANDLER_COMMAND="sudo yum install cups-devel" ;;
4200     freetype)
4201       PKGHANDLER_COMMAND="sudo yum install freetype-devel" ;;
4202     x11)
4203       PKGHANDLER_COMMAND="sudo yum install libXtst-devel libXt-devel libXrender-devel libXi-devel" ;;
4204     ccache)
4205       PKGHANDLER_COMMAND="sudo yum install ccache" ;;
4206   esac
4207 }
4208 
4209 port_help() {
4210   PKGHANDLER_COMMAND=""
4211 }
4212 
4213 pkgutil_help() {
4214   PKGHANDLER_COMMAND=""
4215 }
4216 
4217 pkgadd_help() {
4218   PKGHANDLER_COMMAND=""
4219 }
4220 
4221 # This function will check if we're called from the "configure" wrapper while
4222 # printing --help. If so, we will print out additional information that can
4223 # only be extracted within the autoconf script, and then exit. This must be
4224 # called at the very beginning in configure.ac.
4225 
4226 
4227 
4228 
4229 
4230 
4231 #
4232 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
4233 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4234 #
4235 # This code is free software; you can redistribute it and/or modify it
4236 # under the terms of the GNU General Public License version 2 only, as
4237 # published by the Free Software Foundation.  Oracle designates this
4238 # particular file as subject to the "Classpath" exception as provided
4239 # by Oracle in the LICENSE file that accompanied this code.
4240 #
4241 # This code is distributed in the hope that it will be useful, but WITHOUT
4242 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4243 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4244 # version 2 for more details (a copy is included in the LICENSE file that
4245 # accompanied this code).
4246 #
4247 # You should have received a copy of the GNU General Public License version
4248 # 2 along with this work; if not, write to the Free Software Foundation,
4249 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4250 #
4251 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4252 # or visit www.oracle.com if you need additional information or have any
4253 # questions.
4254 #
4255 
4256 # All valid JVM features, regardless of platform
4257 VALID_JVM_FEATURES="compiler1 compiler2 zero shark minimal dtrace jvmti jvmci \
4258     fprof vm-structs jni-check services management all-gcs nmt cds static-build"
4259 
4260 # All valid JVM variants
4261 VALID_JVM_VARIANTS="server client minimal core zero zeroshark custom"
4262 
4263 ###############################################################################
4264 # Check if the specified JVM variant should be built. To be used in shell if
4265 # constructs, like this:
4266 # if HOTSPOT_CHECK_JVM_VARIANT(server); then
4267 #
4268 # Only valid to use after HOTSPOT_SETUP_JVM_VARIANTS has setup variants.
4269 
4270 # Definition kept in one line to allow inlining in if statements.
4271 # Additional [] needed to keep m4 from mangling shell constructs.
4272 
4273 
4274 ###############################################################################
4275 # Check if the specified JVM features are explicitly enabled. To be used in
4276 # shell if constructs, like this:
4277 # if HOTSPOT_CHECK_JVM_FEATURE(jvmti); then
4278 #
4279 # Only valid to use after HOTSPOT_SETUP_JVM_FEATURES has setup features.
4280 
4281 # Definition kept in one line to allow inlining in if statements.
4282 # Additional [] needed to keep m4 from mangling shell constructs.
4283 
4284 
4285 ###############################################################################
4286 # Check which variants of the JVM that we want to build. Available variants are:
4287 #   server: normal interpreter, and a tiered C1/C2 compiler
4288 #   client: normal interpreter, and C1 (no C2 compiler)
4289 #   minimal: reduced form of client with optional features stripped out
4290 #   core: normal interpreter only, no compiler
4291 #   zero: C++ based interpreter only, no compiler
4292 #   zeroshark: C++ based interpreter, and a llvm-based compiler
4293 #   custom: baseline JVM with no default features
4294 #
4295 
4296 
4297 ###############################################################################
4298 # Check if dtrace should be enabled and has all prerequisites present.
4299 #
4300 
4301 
4302 ###############################################################################
4303 # Set up all JVM features for each JVM variant.
4304 #
4305 
4306 
4307 ###############################################################################
4308 # Validate JVM features once all setup is complete, including custom setup.
4309 #
4310 
4311 
4312 ################################################################################
4313 # Check if gtest should be built
4314 #
4315 
4316 
4317 #
4318 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
4319 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4320 #
4321 # This code is free software; you can redistribute it and/or modify it
4322 # under the terms of the GNU General Public License version 2 only, as
4323 # published by the Free Software Foundation.  Oracle designates this
4324 # particular file as subject to the "Classpath" exception as provided
4325 # by Oracle in the LICENSE file that accompanied this code.
4326 #
4327 # This code is distributed in the hope that it will be useful, but WITHOUT
4328 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4329 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4330 # version 2 for more details (a copy is included in the LICENSE file that
4331 # accompanied this code).
4332 #
4333 # You should have received a copy of the GNU General Public License version
4334 # 2 along with this work; if not, write to the Free Software Foundation,
4335 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4336 #
4337 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4338 # or visit www.oracle.com if you need additional information or have any
4339 # questions.
4340 #
4341 
4342 ###############################################################################
4343 # Check which variant of the JDK that we want to build.
4344 # Currently we have:
4345 #    normal:   standard edition
4346 # but the custom make system may add other variants
4347 #
4348 # Effectively the JDK variant gives a name to a specific set of
4349 # modules to compile into the JDK.
4350 
4351 
4352 ###############################################################################
4353 # Set the debug level
4354 #    release: no debug information, all optimizations, no asserts.
4355 #    optimized: no debug information, all optimizations, no asserts, HotSpot target is 'optimized'.
4356 #    fastdebug: debug information (-g), all optimizations, all asserts
4357 #    slowdebug: debug information (-g), no optimizations, all asserts
4358 
4359 
4360 ###############################################################################
4361 #
4362 # Should we build only OpenJDK even if closed sources are present?
4363 #
4364 
4365 
4366 
4367 
4368 ###############################################################################
4369 #
4370 # Enable or disable the elliptic curve crypto implementation
4371 #
4372 
4373 
4374 
4375 
4376 ################################################################################
4377 #
4378 # Gcov coverage data for hotspot
4379 #
4380 
4381 
4382 ################################################################################
4383 #
4384 # Static build support.  When enabled will generate static
4385 # libraries instead of shared libraries for all JDK libs.
4386 #
4387 
4388 
4389 ################################################################################
4390 #
4391 # jlink options.
4392 # We always keep packaged modules in JDK image.
4393 #
4394 
4395 
4396 ################################################################################
4397 #
4398 # Check if building of the jtreg failure handler should be enabled.
4399 #
4400 
4401 
4402 ################################################################################
4403 #
4404 # Enable or disable generation of the classlist at build time
4405 #
4406 
4407 
4408 #
4409 # Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
4410 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4411 #
4412 # This code is free software; you can redistribute it and/or modify it
4413 # under the terms of the GNU General Public License version 2 only, as
4414 # published by the Free Software Foundation.  Oracle designates this
4415 # particular file as subject to the "Classpath" exception as provided
4416 # by Oracle in the LICENSE file that accompanied this code.
4417 #
4418 # This code is distributed in the hope that it will be useful, but WITHOUT
4419 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4420 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4421 # version 2 for more details (a copy is included in the LICENSE file that
4422 # accompanied this code).
4423 #
4424 # You should have received a copy of the GNU General Public License version
4425 # 2 along with this work; if not, write to the Free Software Foundation,
4426 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4427 #
4428 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4429 # or visit www.oracle.com if you need additional information or have any
4430 # questions.
4431 #
4432 
4433 ###############################################################################
4434 #
4435 # Setup version numbers
4436 #
4437 
4438 # Verify that a given string represents a valid version number, and assign it
4439 # to a variable.
4440 
4441 # Argument 1: the variable to assign to
4442 # Argument 2: the value given by the user
4443 
4444 
4445 
4446 
4447 #
4448 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
4449 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4450 #
4451 # This code is free software; you can redistribute it and/or modify it
4452 # under the terms of the GNU General Public License version 2 only, as
4453 # published by the Free Software Foundation.  Oracle designates this
4454 # particular file as subject to the "Classpath" exception as provided
4455 # by Oracle in the LICENSE file that accompanied this code.
4456 #
4457 # This code is distributed in the hope that it will be useful, but WITHOUT
4458 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4459 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4460 # version 2 for more details (a copy is included in the LICENSE file that
4461 # accompanied this code).
4462 #
4463 # You should have received a copy of the GNU General Public License version
4464 # 2 along with this work; if not, write to the Free Software Foundation,
4465 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4466 #
4467 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4468 # or visit www.oracle.com if you need additional information or have any
4469 # questions.
4470 #
4471 
4472 # Major library component reside in separate files.
4473 #
4474 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
4475 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4476 #
4477 # This code is free software; you can redistribute it and/or modify it
4478 # under the terms of the GNU General Public License version 2 only, as
4479 # published by the Free Software Foundation.  Oracle designates this
4480 # particular file as subject to the "Classpath" exception as provided
4481 # by Oracle in the LICENSE file that accompanied this code.
4482 #
4483 # This code is distributed in the hope that it will be useful, but WITHOUT
4484 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4485 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4486 # version 2 for more details (a copy is included in the LICENSE file that
4487 # accompanied this code).
4488 #
4489 # You should have received a copy of the GNU General Public License version
4490 # 2 along with this work; if not, write to the Free Software Foundation,
4491 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4492 #
4493 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4494 # or visit www.oracle.com if you need additional information or have any
4495 # questions.
4496 #
4497 
4498 ################################################################################
4499 # Setup alsa (Advanced Linux Sound Architecture)
4500 ################################################################################
4501 
4502 
4503 #
4504 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
4505 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4506 #
4507 # This code is free software; you can redistribute it and/or modify it
4508 # under the terms of the GNU General Public License version 2 only, as
4509 # published by the Free Software Foundation.  Oracle designates this
4510 # particular file as subject to the "Classpath" exception as provided
4511 # by Oracle in the LICENSE file that accompanied this code.
4512 #
4513 # This code is distributed in the hope that it will be useful, but WITHOUT
4514 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4515 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4516 # version 2 for more details (a copy is included in the LICENSE file that
4517 # accompanied this code).
4518 #
4519 # You should have received a copy of the GNU General Public License version
4520 # 2 along with this work; if not, write to the Free Software Foundation,
4521 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4522 #
4523 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4524 # or visit www.oracle.com if you need additional information or have any
4525 # questions.
4526 #
4527 
4528 ################################################################################
4529 # Setup bundled libraries.
4530 #
4531 # For libjpeg, giflib, libpng, lcms2 and zlib, the source is present in the
4532 # OpenJDK repository. Default is to use these libraries as bundled, but they
4533 # might be replaced by en external version by the user.
4534 ################################################################################
4535 
4536 
4537 ################################################################################
4538 # Setup libjpeg
4539 ################################################################################
4540 
4541 
4542 ################################################################################
4543 # Setup giflib
4544 ################################################################################
4545 
4546 
4547 ################################################################################
4548 # Setup libpng
4549 ################################################################################
4550 
4551 
4552 ################################################################################
4553 # Setup zlib
4554 ################################################################################
4555 
4556 
4557 ################################################################################
4558 # Setup lcms (Little CMS)
4559 ################################################################################
4560 
4561 
4562 #
4563 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
4564 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4565 #
4566 # This code is free software; you can redistribute it and/or modify it
4567 # under the terms of the GNU General Public License version 2 only, as
4568 # published by the Free Software Foundation.  Oracle designates this
4569 # particular file as subject to the "Classpath" exception as provided
4570 # by Oracle in the LICENSE file that accompanied this code.
4571 #
4572 # This code is distributed in the hope that it will be useful, but WITHOUT
4573 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4574 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4575 # version 2 for more details (a copy is included in the LICENSE file that
4576 # accompanied this code).
4577 #
4578 # You should have received a copy of the GNU General Public License version
4579 # 2 along with this work; if not, write to the Free Software Foundation,
4580 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4581 #
4582 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4583 # or visit www.oracle.com if you need additional information or have any
4584 # questions.
4585 #
4586 
4587 ################################################################################
4588 # Setup cups (Common Unix Printing System)
4589 ################################################################################
4590 
4591 
4592 #
4593 # Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
4594 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4595 #
4596 # This code is free software; you can redistribute it and/or modify it
4597 # under the terms of the GNU General Public License version 2 only, as
4598 # published by the Free Software Foundation.  Oracle designates this
4599 # particular file as subject to the "Classpath" exception as provided
4600 # by Oracle in the LICENSE file that accompanied this code.
4601 #
4602 # This code is distributed in the hope that it will be useful, but WITHOUT
4603 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4604 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4605 # version 2 for more details (a copy is included in the LICENSE file that
4606 # accompanied this code).
4607 #
4608 # You should have received a copy of the GNU General Public License version
4609 # 2 along with this work; if not, write to the Free Software Foundation,
4610 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4611 #
4612 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4613 # or visit www.oracle.com if you need additional information or have any
4614 # questions.
4615 #
4616 
4617 ################################################################################
4618 # Setup libffi (Foreign Function Interface)
4619 ################################################################################
4620 
4621 
4622 #
4623 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
4624 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4625 #
4626 # This code is free software; you can redistribute it and/or modify it
4627 # under the terms of the GNU General Public License version 2 only, as
4628 # published by the Free Software Foundation.  Oracle designates this
4629 # particular file as subject to the "Classpath" exception as provided
4630 # by Oracle in the LICENSE file that accompanied this code.
4631 #
4632 # This code is distributed in the hope that it will be useful, but WITHOUT
4633 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4634 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4635 # version 2 for more details (a copy is included in the LICENSE file that
4636 # accompanied this code).
4637 #
4638 # You should have received a copy of the GNU General Public License version
4639 # 2 along with this work; if not, write to the Free Software Foundation,
4640 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4641 #
4642 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4643 # or visit www.oracle.com if you need additional information or have any
4644 # questions.
4645 #
4646 
4647 ################################################################################
4648 # Build the freetype lib from source
4649 ################################################################################
4650 
4651 
4652 ################################################################################
4653 # Check if a potential freeype library match is correct and usable
4654 ################################################################################
4655 
4656 
4657 ################################################################################
4658 # Setup freetype (The FreeType2 font rendering library)
4659 ################################################################################
4660 
4661 
4662 #
4663 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
4664 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4665 #
4666 # This code is free software; you can redistribute it and/or modify it
4667 # under the terms of the GNU General Public License version 2 only, as
4668 # published by the Free Software Foundation.  Oracle designates this
4669 # particular file as subject to the "Classpath" exception as provided
4670 # by Oracle in the LICENSE file that accompanied this code.
4671 #
4672 # This code is distributed in the hope that it will be useful, but WITHOUT
4673 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4674 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4675 # version 2 for more details (a copy is included in the LICENSE file that
4676 # accompanied this code).
4677 #
4678 # You should have received a copy of the GNU General Public License version
4679 # 2 along with this work; if not, write to the Free Software Foundation,
4680 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4681 #
4682 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4683 # or visit www.oracle.com if you need additional information or have any
4684 # questions.
4685 #
4686 
4687 ################################################################################
4688 # Setup the standard C/C++ runtime libraries.
4689 #
4690 # Most importantly, determine if stdc++ should be linked statically or
4691 # dynamically.
4692 ################################################################################
4693 
4694 
4695 #
4696 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
4697 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4698 #
4699 # This code is free software; you can redistribute it and/or modify it
4700 # under the terms of the GNU General Public License version 2 only, as
4701 # published by the Free Software Foundation.  Oracle designates this
4702 # particular file as subject to the "Classpath" exception as provided
4703 # by Oracle in the LICENSE file that accompanied this code.
4704 #
4705 # This code is distributed in the hope that it will be useful, but WITHOUT
4706 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4707 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4708 # version 2 for more details (a copy is included in the LICENSE file that
4709 # accompanied this code).
4710 #
4711 # You should have received a copy of the GNU General Public License version
4712 # 2 along with this work; if not, write to the Free Software Foundation,
4713 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4714 #
4715 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4716 # or visit www.oracle.com if you need additional information or have any
4717 # questions.
4718 #
4719 
4720 ################################################################################
4721 # Setup X11 Windows system
4722 ################################################################################
4723 
4724 
4725 
4726 ################################################################################
4727 # Determine which libraries are needed for this configuration
4728 ################################################################################
4729 
4730 
4731 ################################################################################
4732 # Parse library options, and setup needed libraries
4733 ################################################################################
4734 
4735 
4736 ################################################################################
4737 # Setup llvm (Low-Level VM)
4738 ################################################################################
4739 
4740 
4741 ################################################################################
4742 # Setup various libraries, typically small system libraries
4743 ################################################################################
4744 
4745 
4746 ################################################################################
4747 # libstlport.so.1 is needed for running gtest on Solaris. Find it to
4748 # redistribute it in the test image.
4749 ################################################################################
4750 
4751 
4752 
4753 #
4754 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
4755 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4756 #
4757 # This code is free software; you can redistribute it and/or modify it
4758 # under the terms of the GNU General Public License version 2 only, as
4759 # published by the Free Software Foundation.  Oracle designates this
4760 # particular file as subject to the "Classpath" exception as provided
4761 # by Oracle in the LICENSE file that accompanied this code.
4762 #
4763 # This code is distributed in the hope that it will be useful, but WITHOUT
4764 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4765 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4766 # version 2 for more details (a copy is included in the LICENSE file that
4767 # accompanied this code).
4768 #
4769 # You should have received a copy of the GNU General Public License version
4770 # 2 along with this work; if not, write to the Free Software Foundation,
4771 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4772 #
4773 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4774 # or visit www.oracle.com if you need additional information or have any
4775 # questions.
4776 #
4777 
4778 # Support macro for PLATFORM_EXTRACT_TARGET_AND_BUILD.
4779 # Converts autoconf style CPU name to OpenJDK style, into
4780 # VAR_CPU, VAR_CPU_ARCH, VAR_CPU_BITS and VAR_CPU_ENDIAN.
4781 
4782 
4783 # Support macro for PLATFORM_EXTRACT_TARGET_AND_BUILD.
4784 # Converts autoconf style OS name to OpenJDK style, into
4785 # VAR_OS, VAR_OS_TYPE and VAR_OS_ENV.
4786 
4787 
4788 # Expects $host_os $host_cpu $build_os and $build_cpu
4789 # and $with_target_bits to have been setup!
4790 #
4791 # Translate the standard triplet(quadruplet) definition
4792 # of the target/build system into OPENJDK_TARGET_OS, OPENJDK_TARGET_CPU,
4793 # OPENJDK_BUILD_OS, etc.
4794 
4795 
4796 # Check if a reduced build (32-bit on 64-bit platforms) is requested, and modify behaviour
4797 # accordingly. Must be done after setting up build and target system, but before
4798 # doing anything else with these values.
4799 
4800 
4801 # Setup the legacy variables, for controlling the old makefiles.
4802 #
4803 
4804 
4805 # $1 - Either TARGET or BUILD to setup the variables for.
4806 
4807 
4808 
4809 
4810 #%%% Build and target systems %%%
4811 
4812 
4813 
4814 
4815 # Support macro for PLATFORM_SETUP_OPENJDK_TARGET_BITS.
4816 # Add -mX to various FLAGS variables.
4817 
4818 
4819 
4820 
4821 
4822 
4823 #
4824 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
4825 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4826 #
4827 # This code is free software; you can redistribute it and/or modify it
4828 # under the terms of the GNU General Public License version 2 only, as
4829 # published by the Free Software Foundation.  Oracle designates this
4830 # particular file as subject to the "Classpath" exception as provided
4831 # by Oracle in the LICENSE file that accompanied this code.
4832 #
4833 # This code is distributed in the hope that it will be useful, but WITHOUT
4834 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4835 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4836 # version 2 for more details (a copy is included in the LICENSE file that
4837 # accompanied this code).
4838 #
4839 # You should have received a copy of the GNU General Public License version
4840 # 2 along with this work; if not, write to the Free Software Foundation,
4841 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4842 #
4843 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4844 # or visit www.oracle.com if you need additional information or have any
4845 # questions.
4846 #
4847 
4848 
4849 
4850 
4851 
4852 
4853 
4854 ################################################################################
4855 # Define a mechanism for importing extra prebuilt modules
4856 #
4857 
4858 
4859 
4860 #
4861 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
4862 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4863 #
4864 # This code is free software; you can redistribute it and/or modify it
4865 # under the terms of the GNU General Public License version 2 only, as
4866 # published by the Free Software Foundation.  Oracle designates this
4867 # particular file as subject to the "Classpath" exception as provided
4868 # by Oracle in the LICENSE file that accompanied this code.
4869 #
4870 # This code is distributed in the hope that it will be useful, but WITHOUT
4871 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4872 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4873 # version 2 for more details (a copy is included in the LICENSE file that
4874 # accompanied this code).
4875 #
4876 # You should have received a copy of the GNU General Public License version
4877 # 2 along with this work; if not, write to the Free Software Foundation,
4878 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4879 #
4880 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4881 # or visit www.oracle.com if you need additional information or have any
4882 # questions.
4883 #
4884 
4885 ########################################################################
4886 # This file is responsible for detecting, verifying and setting up the
4887 # toolchain, i.e. the compiler, linker and related utilities. It will setup
4888 # proper paths to the binaries, but it will not setup any flags.
4889 #
4890 # The binaries used is determined by the toolchain type, which is the family of
4891 # compilers and related tools that are used.
4892 ########################################################################
4893 
4894 
4895 # All valid toolchains, regardless of platform (used by help.m4)
4896 VALID_TOOLCHAINS_all="gcc clang solstudio xlc microsoft"
4897 
4898 # These toolchains are valid on different platforms
4899 VALID_TOOLCHAINS_linux="gcc clang"
4900 VALID_TOOLCHAINS_solaris="solstudio"
4901 VALID_TOOLCHAINS_macosx="gcc clang"
4902 VALID_TOOLCHAINS_aix="xlc"
4903 VALID_TOOLCHAINS_windows="microsoft"
4904 
4905 # Toolchain descriptions
4906 TOOLCHAIN_DESCRIPTION_clang="clang/LLVM"
4907 TOOLCHAIN_DESCRIPTION_gcc="GNU Compiler Collection"
4908 TOOLCHAIN_DESCRIPTION_microsoft="Microsoft Visual Studio"
4909 TOOLCHAIN_DESCRIPTION_solstudio="Oracle Solaris Studio"
4910 TOOLCHAIN_DESCRIPTION_xlc="IBM XL C/C++"
4911 
4912 # Minimum supported versions, empty means unspecified
4913 TOOLCHAIN_MINIMUM_VERSION_clang="3.2"
4914 TOOLCHAIN_MINIMUM_VERSION_gcc="4.3"
4915 TOOLCHAIN_MINIMUM_VERSION_microsoft=""
4916 TOOLCHAIN_MINIMUM_VERSION_solstudio="5.12"
4917 TOOLCHAIN_MINIMUM_VERSION_xlc=""
4918 
4919 # Prepare the system so that TOOLCHAIN_CHECK_COMPILER_VERSION can be called.
4920 # Must have CC_VERSION_NUMBER and CXX_VERSION_NUMBER.
4921 # $1 - optional variable prefix for compiler and version variables (BUILD_)
4922 # $2 - optional variable prefix for comparable variable (OPENJDK_BUILD_)
4923 
4924 
4925 # Check if the configured compiler (C and C++) is of a specific version or
4926 # newer. TOOLCHAIN_PREPARE_FOR_VERSION_COMPARISONS must have been called before.
4927 #
4928 # Arguments:
4929 #   VERSION:   The version string to check against the found version
4930 #   IF_AT_LEAST:   block to run if the compiler is at least this version (>=)
4931 #   IF_OLDER_THAN:   block to run if the compiler is older than this version (<)
4932 #   PREFIX:   Optional variable prefix for compiler to compare version for (OPENJDK_BUILD_)
4933 
4934 
4935 
4936 
4937 # Setup a number of variables describing how native output files are
4938 # named on this platform/toolchain.
4939 
4940 
4941 # Determine which toolchain type to use, and make sure it is valid for this
4942 # platform. Setup various information about the selected toolchain.
4943 
4944 
4945 # Before we start detecting the toolchain executables, we might need some
4946 # special setup, e.g. additional paths etc.
4947 
4948 
4949 # Restore path, etc
4950 
4951 
4952 # Check if a compiler is of the toolchain type we expect, and save the version
4953 # information from it. If the compiler does not match the expected type,
4954 # this function will abort using AC_MSG_ERROR. If it matches, the version will
4955 # be stored in CC_VERSION_NUMBER/CXX_VERSION_NUMBER (as a dotted number), and
4956 # the full version string in CC_VERSION_STRING/CXX_VERSION_STRING.
4957 #
4958 # $1 = compiler to test (CC or CXX)
4959 # $2 = human readable name of compiler (C or C++)
4960 
4961 
4962 # Try to locate the given C or C++ compiler in the path, or otherwise.
4963 #
4964 # $1 = compiler to test (CC or CXX)
4965 # $2 = human readable name of compiler (C or C++)
4966 # $3 = list of compiler names to search for
4967 
4968 
4969 # Detect the core components of the toolchain, i.e. the compilers (CC and CXX),
4970 # preprocessor (CPP and CXXCPP), the linker (LD), the assembler (AS) and the
4971 # archiver (AR). Verify that the compilers are correct according to the
4972 # toolchain type.
4973 
4974 
4975 # Setup additional tools that is considered a part of the toolchain, but not the
4976 # core part. Many of these are highly platform-specific and do not exist,
4977 # and/or are not needed on all platforms.
4978 
4979 
4980 # Setup the build tools (i.e, the compiler and linker used to build programs
4981 # that should be run on the build platform, not the target platform, as a build
4982 # helper). Since the non-cross-compile case uses the normal, target compilers
4983 # for this, we can only do this after these have been setup.
4984 
4985 
4986 # Setup legacy variables that are still needed as alternative ways to refer to
4987 # parts of the toolchain.
4988 
4989 
4990 # Do some additional checks on the detected tools.
4991 
4992 
4993 # Setup the JTReg Regression Test Harness.
4994 
4995 
4996 #
4997 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
4998 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4999 #
5000 # This code is free software; you can redistribute it and/or modify it
5001 # under the terms of the GNU General Public License version 2 only, as
5002 # published by the Free Software Foundation.  Oracle designates this
5003 # particular file as subject to the "Classpath" exception as provided
5004 # by Oracle in the LICENSE file that accompanied this code.
5005 #
5006 # This code is distributed in the hope that it will be useful, but WITHOUT
5007 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
5008 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
5009 # version 2 for more details (a copy is included in the LICENSE file that
5010 # accompanied this code).
5011 #
5012 # You should have received a copy of the GNU General Public License version
5013 # 2 along with this work; if not, write to the Free Software Foundation,
5014 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
5015 #
5016 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
5017 # or visit www.oracle.com if you need additional information or have any
5018 # questions.
5019 #
5020 
5021 ################################################################################
5022 # The order of these defines the priority by which we try to find them.
5023 VALID_VS_VERSIONS="2013 2012 2010"
5024 
5025 VS_DESCRIPTION_2010="Microsoft Visual Studio 2010"
5026 VS_VERSION_INTERNAL_2010=100
5027 VS_MSVCR_2010=msvcr100.dll
5028 # We don't use msvcp on Visual Studio 2010
5029 #VS_MSVCP_2010=msvcp100.dll
5030 VS_ENVVAR_2010="VS100COMNTOOLS"
5031 VS_VS_INSTALLDIR_2010="Microsoft Visual Studio 10.0"
5032 VS_SDK_INSTALLDIR_2010="Microsoft SDKs/Windows/v7.1"
5033 VS_VS_PLATFORM_NAME_2010="v100"
5034 VS_SDK_PLATFORM_NAME_2010="Windows7.1SDK"
5035 
5036 VS_DESCRIPTION_2012="Microsoft Visual Studio 2012"
5037 VS_VERSION_INTERNAL_2012=110
5038 VS_MSVCR_2012=msvcr110.dll
5039 VS_MSVCP_2012=msvcp110.dll
5040 VS_ENVVAR_2012="VS110COMNTOOLS"
5041 VS_VS_INSTALLDIR_2012="Microsoft Visual Studio 11.0"
5042 VS_SDK_INSTALLDIR_2012=
5043 VS_VS_PLATFORM_NAME_2012="v110"
5044 VS_SDK_PLATFORM_NAME_2012=
5045 
5046 VS_DESCRIPTION_2013="Microsoft Visual Studio 2013"
5047 VS_VERSION_INTERNAL_2013=120
5048 VS_MSVCR_2013=msvcr120.dll
5049 VS_MSVCP_2013=msvcp120.dll
5050 VS_ENVVAR_2013="VS120COMNTOOLS"
5051 VS_VS_INSTALLDIR_2013="Microsoft Visual Studio 12.0"
5052 VS_SDK_INSTALLDIR_2013=
5053 VS_VS_PLATFORM_NAME_2013="v120"
5054 VS_SDK_PLATFORM_NAME_2013=
5055 
5056 ################################################################################
5057 
5058 
5059 
5060 ################################################################################
5061 
5062 
5063 
5064 ################################################################################
5065 # Finds the bat or cmd file in Visual Studio or the SDK that sets up a proper
5066 # build environment and assigns it to VS_ENV_CMD
5067 
5068 
5069 ################################################################################
5070 
5071 
5072 
5073 ################################################################################
5074 # Check if the VS env variables were setup prior to running configure.
5075 # If not, then find vcvarsall.bat and run it automatically, and integrate
5076 # the set env variables into the spec file.
5077 
5078 
5079 
5080 
5081 
5082 
5083 
5084 
5085 
5086 
5087 
5088 
5089 
5090 
5091 # This line needs to be here, verbatim, after all includes and the dummy hook
5092 # definitions. It is replaced with custom functionality when building
5093 # custom sources.
5094 #CUSTOM_AUTOCONF_INCLUDE
5095 
5096 # Do not change or remove the following line, it is needed for consistency checks:
5097 DATE_WHEN_GENERATED=1467382439
5098 
5099 ###############################################################################
5100 #
5101 # Initialization / Boot-strapping
5102 #
5103 # The bootstrapping process needs to solve the "chicken or the egg" problem,
5104 # thus it jumps back and forth, each time gaining something needed later on.
5105 #
5106 ###############################################################################
5107 
5108 # If we are requested to print additional help, do that and then exit.
5109 # This must be the very first call.
5110 
5111   if test "x$CONFIGURE_PRINT_ADDITIONAL_HELP" != x; then
5112 
5113     # Print available toolchains
5114     $PRINTF "The following toolchains are available as arguments to --with-toolchain-type.\n"
5115     $PRINTF "Which are valid to use depends on the build platform.\n"
5116     for toolchain in $VALID_TOOLCHAINS_all; do
5117       # Use indirect variable referencing
5118       toolchain_var_name=TOOLCHAIN_DESCRIPTION_$toolchain
5119       TOOLCHAIN_DESCRIPTION=${!toolchain_var_name}
5120       $PRINTF "  %-10s  %s\n" $toolchain "$TOOLCHAIN_DESCRIPTION"
5121     done
5122     $PRINTF "\n"
5123 
5124     # Print available jvm features
5125     $PRINTF "The following JVM features are available as arguments to --with-jvm-features.\n"
5126     $PRINTF "Which are valid to use depends on the target platform.\n  "
5127     $PRINTF "%s " $VALID_JVM_FEATURES
5128     $PRINTF "\n"
5129 
5130     # And now exit directly
5131     exit 0
5132   fi
5133 
5134 
5135 # Basic initialization that must happen first of all in the normal process.
5136 
5137   # Save the original command line. This is passed to us by the wrapper configure script.
5138 
5139   # Save the path variable before it gets changed
5140   ORIGINAL_PATH="$PATH"
5141 
5142   DATE_WHEN_CONFIGURED=`LANG=C date`
5143 
5144   { $as_echo "$as_me:${as_lineno-$LINENO}: Configuration created at $DATE_WHEN_CONFIGURED." >&5
5145 $as_echo "$as_me: Configuration created at $DATE_WHEN_CONFIGURED." >&6;}
5146   { $as_echo "$as_me:${as_lineno-$LINENO}: configure script generated at timestamp $DATE_WHEN_GENERATED." >&5
5147 $as_echo "$as_me: configure script generated at timestamp $DATE_WHEN_GENERATED." >&6;}
5148 
5149 
5150   # Start with tools that do not need have cross compilation support
5151   # and can be expected to be found in the default PATH. These tools are
5152   # used by configure.
5153 
5154   # First are all the simple required tools.
5155 
5156 
5157 
5158   # Publish this variable in the help.
5159 
5160 
5161   if [ -z "${BASENAME+x}" ]; then
5162     # The variable is not set by user, try to locate tool using the code snippet
5163     for ac_prog in basename
5164 do
5165   # Extract the first word of "$ac_prog", so it can be a program name with args.
5166 set dummy $ac_prog; ac_word=$2
5167 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5168 $as_echo_n "checking for $ac_word... " >&6; }
5169 if ${ac_cv_path_BASENAME+:} false; then :
5170   $as_echo_n "(cached) " >&6
5171 else
5172   case $BASENAME in
5173   [\\/]* | ?:[\\/]*)
5174   ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
5175   ;;
5176   *)
5177   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5178 for as_dir in $PATH
5179 do
5180   IFS=$as_save_IFS
5181   test -z "$as_dir" && as_dir=.
5182     for ac_exec_ext in '' $ac_executable_extensions; do
5183   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5184     ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
5185     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5186     break 2
5187   fi
5188 done
5189   done
5190 IFS=$as_save_IFS
5191 
5192   ;;
5193 esac
5194 fi
5195 BASENAME=$ac_cv_path_BASENAME
5196 if test -n "$BASENAME"; then
5197   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
5198 $as_echo "$BASENAME" >&6; }
5199 else
5200   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5201 $as_echo "no" >&6; }
5202 fi
5203 
5204 
5205   test -n "$BASENAME" && break
5206 done
5207 
5208   else
5209     # The variable is set, but is it from the command line or the environment?
5210 
5211     # Try to remove the string !BASENAME! from our list.
5212     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BASENAME!/}
5213     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5214       # If it failed, the variable was not from the command line. Ignore it,
5215       # but warn the user (except for BASH, which is always set by the calling BASH).
5216       if test "xBASENAME" != xBASH; then
5217         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BASENAME from the environment. Use command line variables instead." >&5
5218 $as_echo "$as_me: WARNING: Ignoring value of BASENAME from the environment. Use command line variables instead." >&2;}
5219       fi
5220       # Try to locate tool using the code snippet
5221       for ac_prog in basename
5222 do
5223   # Extract the first word of "$ac_prog", so it can be a program name with args.
5224 set dummy $ac_prog; ac_word=$2
5225 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5226 $as_echo_n "checking for $ac_word... " >&6; }
5227 if ${ac_cv_path_BASENAME+:} false; then :
5228   $as_echo_n "(cached) " >&6
5229 else
5230   case $BASENAME in
5231   [\\/]* | ?:[\\/]*)
5232   ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
5233   ;;
5234   *)
5235   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5236 for as_dir in $PATH
5237 do
5238   IFS=$as_save_IFS
5239   test -z "$as_dir" && as_dir=.
5240     for ac_exec_ext in '' $ac_executable_extensions; do
5241   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5242     ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
5243     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5244     break 2
5245   fi
5246 done
5247   done
5248 IFS=$as_save_IFS
5249 
5250   ;;
5251 esac
5252 fi
5253 BASENAME=$ac_cv_path_BASENAME
5254 if test -n "$BASENAME"; then
5255   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
5256 $as_echo "$BASENAME" >&6; }
5257 else
5258   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5259 $as_echo "no" >&6; }
5260 fi
5261 
5262 
5263   test -n "$BASENAME" && break
5264 done
5265 
5266     else
5267       # If it succeeded, then it was overridden by the user. We will use it
5268       # for the tool.
5269 
5270       # First remove it from the list of overridden variables, so we can test
5271       # for unknown variables in the end.
5272       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5273 
5274       # Check if we try to supply an empty value
5275       if test "x$BASENAME" = x; then
5276         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool BASENAME= (no value)" >&5
5277 $as_echo "$as_me: Setting user supplied tool BASENAME= (no value)" >&6;}
5278         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASENAME" >&5
5279 $as_echo_n "checking for BASENAME... " >&6; }
5280         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
5281 $as_echo "disabled" >&6; }
5282       else
5283         # Check if the provided tool contains a complete path.
5284         tool_specified="$BASENAME"
5285         tool_basename="${tool_specified##*/}"
5286         if test "x$tool_basename" = "x$tool_specified"; then
5287           # A command without a complete path is provided, search $PATH.
5288           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BASENAME=$tool_basename" >&5
5289 $as_echo "$as_me: Will search for user supplied tool BASENAME=$tool_basename" >&6;}
5290           # Extract the first word of "$tool_basename", so it can be a program name with args.
5291 set dummy $tool_basename; ac_word=$2
5292 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5293 $as_echo_n "checking for $ac_word... " >&6; }
5294 if ${ac_cv_path_BASENAME+:} false; then :
5295   $as_echo_n "(cached) " >&6
5296 else
5297   case $BASENAME in
5298   [\\/]* | ?:[\\/]*)
5299   ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
5300   ;;
5301   *)
5302   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5303 for as_dir in $PATH
5304 do
5305   IFS=$as_save_IFS
5306   test -z "$as_dir" && as_dir=.
5307     for ac_exec_ext in '' $ac_executable_extensions; do
5308   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5309     ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
5310     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5311     break 2
5312   fi
5313 done
5314   done
5315 IFS=$as_save_IFS
5316 
5317   ;;
5318 esac
5319 fi
5320 BASENAME=$ac_cv_path_BASENAME
5321 if test -n "$BASENAME"; then
5322   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
5323 $as_echo "$BASENAME" >&6; }
5324 else
5325   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5326 $as_echo "no" >&6; }
5327 fi
5328 
5329 
5330           if test "x$BASENAME" = x; then
5331             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5332           fi
5333         else
5334           # Otherwise we believe it is a complete path. Use it as it is.
5335           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BASENAME=$tool_specified" >&5
5336 $as_echo "$as_me: Will use user supplied tool BASENAME=$tool_specified" >&6;}
5337           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASENAME" >&5
5338 $as_echo_n "checking for BASENAME... " >&6; }
5339           if test ! -x "$tool_specified"; then
5340             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5341 $as_echo "not found" >&6; }
5342             as_fn_error $? "User supplied tool BASENAME=$tool_specified does not exist or is not executable" "$LINENO" 5
5343           fi
5344           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5345 $as_echo "$tool_specified" >&6; }
5346         fi
5347       fi
5348     fi
5349 
5350   fi
5351 
5352 
5353 
5354   if test "x$BASENAME" = x; then
5355     as_fn_error $? "Could not find required tool for BASENAME" "$LINENO" 5
5356   fi
5357 
5358 
5359 
5360 
5361 
5362   # Publish this variable in the help.
5363 
5364 
5365   if [ -z "${BASH+x}" ]; then
5366     # The variable is not set by user, try to locate tool using the code snippet
5367     for ac_prog in bash
5368 do
5369   # Extract the first word of "$ac_prog", so it can be a program name with args.
5370 set dummy $ac_prog; ac_word=$2
5371 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5372 $as_echo_n "checking for $ac_word... " >&6; }
5373 if ${ac_cv_path_BASH+:} false; then :
5374   $as_echo_n "(cached) " >&6
5375 else
5376   case $BASH in
5377   [\\/]* | ?:[\\/]*)
5378   ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
5379   ;;
5380   *)
5381   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5382 for as_dir in $PATH
5383 do
5384   IFS=$as_save_IFS
5385   test -z "$as_dir" && as_dir=.
5386     for ac_exec_ext in '' $ac_executable_extensions; do
5387   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5388     ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
5389     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5390     break 2
5391   fi
5392 done
5393   done
5394 IFS=$as_save_IFS
5395 
5396   ;;
5397 esac
5398 fi
5399 BASH=$ac_cv_path_BASH
5400 if test -n "$BASH"; then
5401   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
5402 $as_echo "$BASH" >&6; }
5403 else
5404   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5405 $as_echo "no" >&6; }
5406 fi
5407 
5408 
5409   test -n "$BASH" && break
5410 done
5411 
5412   else
5413     # The variable is set, but is it from the command line or the environment?
5414 
5415     # Try to remove the string !BASH! from our list.
5416     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BASH!/}
5417     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5418       # If it failed, the variable was not from the command line. Ignore it,
5419       # but warn the user (except for BASH, which is always set by the calling BASH).
5420       if test "xBASH" != xBASH; then
5421         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BASH from the environment. Use command line variables instead." >&5
5422 $as_echo "$as_me: WARNING: Ignoring value of BASH from the environment. Use command line variables instead." >&2;}
5423       fi
5424       # Try to locate tool using the code snippet
5425       for ac_prog in bash
5426 do
5427   # Extract the first word of "$ac_prog", so it can be a program name with args.
5428 set dummy $ac_prog; ac_word=$2
5429 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5430 $as_echo_n "checking for $ac_word... " >&6; }
5431 if ${ac_cv_path_BASH+:} false; then :
5432   $as_echo_n "(cached) " >&6
5433 else
5434   case $BASH in
5435   [\\/]* | ?:[\\/]*)
5436   ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
5437   ;;
5438   *)
5439   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5440 for as_dir in $PATH
5441 do
5442   IFS=$as_save_IFS
5443   test -z "$as_dir" && as_dir=.
5444     for ac_exec_ext in '' $ac_executable_extensions; do
5445   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5446     ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
5447     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5448     break 2
5449   fi
5450 done
5451   done
5452 IFS=$as_save_IFS
5453 
5454   ;;
5455 esac
5456 fi
5457 BASH=$ac_cv_path_BASH
5458 if test -n "$BASH"; then
5459   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
5460 $as_echo "$BASH" >&6; }
5461 else
5462   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5463 $as_echo "no" >&6; }
5464 fi
5465 
5466 
5467   test -n "$BASH" && break
5468 done
5469 
5470     else
5471       # If it succeeded, then it was overridden by the user. We will use it
5472       # for the tool.
5473 
5474       # First remove it from the list of overridden variables, so we can test
5475       # for unknown variables in the end.
5476       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5477 
5478       # Check if we try to supply an empty value
5479       if test "x$BASH" = x; then
5480         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool BASH= (no value)" >&5
5481 $as_echo "$as_me: Setting user supplied tool BASH= (no value)" >&6;}
5482         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASH" >&5
5483 $as_echo_n "checking for BASH... " >&6; }
5484         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
5485 $as_echo "disabled" >&6; }
5486       else
5487         # Check if the provided tool contains a complete path.
5488         tool_specified="$BASH"
5489         tool_basename="${tool_specified##*/}"
5490         if test "x$tool_basename" = "x$tool_specified"; then
5491           # A command without a complete path is provided, search $PATH.
5492           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BASH=$tool_basename" >&5
5493 $as_echo "$as_me: Will search for user supplied tool BASH=$tool_basename" >&6;}
5494           # Extract the first word of "$tool_basename", so it can be a program name with args.
5495 set dummy $tool_basename; ac_word=$2
5496 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5497 $as_echo_n "checking for $ac_word... " >&6; }
5498 if ${ac_cv_path_BASH+:} false; then :
5499   $as_echo_n "(cached) " >&6
5500 else
5501   case $BASH in
5502   [\\/]* | ?:[\\/]*)
5503   ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
5504   ;;
5505   *)
5506   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5507 for as_dir in $PATH
5508 do
5509   IFS=$as_save_IFS
5510   test -z "$as_dir" && as_dir=.
5511     for ac_exec_ext in '' $ac_executable_extensions; do
5512   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5513     ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
5514     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5515     break 2
5516   fi
5517 done
5518   done
5519 IFS=$as_save_IFS
5520 
5521   ;;
5522 esac
5523 fi
5524 BASH=$ac_cv_path_BASH
5525 if test -n "$BASH"; then
5526   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
5527 $as_echo "$BASH" >&6; }
5528 else
5529   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5530 $as_echo "no" >&6; }
5531 fi
5532 
5533 
5534           if test "x$BASH" = x; then
5535             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5536           fi
5537         else
5538           # Otherwise we believe it is a complete path. Use it as it is.
5539           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BASH=$tool_specified" >&5
5540 $as_echo "$as_me: Will use user supplied tool BASH=$tool_specified" >&6;}
5541           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASH" >&5
5542 $as_echo_n "checking for BASH... " >&6; }
5543           if test ! -x "$tool_specified"; then
5544             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5545 $as_echo "not found" >&6; }
5546             as_fn_error $? "User supplied tool BASH=$tool_specified does not exist or is not executable" "$LINENO" 5
5547           fi
5548           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5549 $as_echo "$tool_specified" >&6; }
5550         fi
5551       fi
5552     fi
5553 
5554   fi
5555 
5556 
5557 
5558   if test "x$BASH" = x; then
5559     as_fn_error $? "Could not find required tool for BASH" "$LINENO" 5
5560   fi
5561 
5562 
5563 
5564 
5565 
5566   # Publish this variable in the help.
5567 
5568 
5569   if [ -z "${CAT+x}" ]; then
5570     # The variable is not set by user, try to locate tool using the code snippet
5571     for ac_prog in cat
5572 do
5573   # Extract the first word of "$ac_prog", so it can be a program name with args.
5574 set dummy $ac_prog; ac_word=$2
5575 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5576 $as_echo_n "checking for $ac_word... " >&6; }
5577 if ${ac_cv_path_CAT+:} false; then :
5578   $as_echo_n "(cached) " >&6
5579 else
5580   case $CAT in
5581   [\\/]* | ?:[\\/]*)
5582   ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
5583   ;;
5584   *)
5585   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5586 for as_dir in $PATH
5587 do
5588   IFS=$as_save_IFS
5589   test -z "$as_dir" && as_dir=.
5590     for ac_exec_ext in '' $ac_executable_extensions; do
5591   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5592     ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
5593     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5594     break 2
5595   fi
5596 done
5597   done
5598 IFS=$as_save_IFS
5599 
5600   ;;
5601 esac
5602 fi
5603 CAT=$ac_cv_path_CAT
5604 if test -n "$CAT"; then
5605   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
5606 $as_echo "$CAT" >&6; }
5607 else
5608   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5609 $as_echo "no" >&6; }
5610 fi
5611 
5612 
5613   test -n "$CAT" && break
5614 done
5615 
5616   else
5617     # The variable is set, but is it from the command line or the environment?
5618 
5619     # Try to remove the string !CAT! from our list.
5620     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CAT!/}
5621     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5622       # If it failed, the variable was not from the command line. Ignore it,
5623       # but warn the user (except for BASH, which is always set by the calling BASH).
5624       if test "xCAT" != xBASH; then
5625         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CAT from the environment. Use command line variables instead." >&5
5626 $as_echo "$as_me: WARNING: Ignoring value of CAT from the environment. Use command line variables instead." >&2;}
5627       fi
5628       # Try to locate tool using the code snippet
5629       for ac_prog in cat
5630 do
5631   # Extract the first word of "$ac_prog", so it can be a program name with args.
5632 set dummy $ac_prog; ac_word=$2
5633 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5634 $as_echo_n "checking for $ac_word... " >&6; }
5635 if ${ac_cv_path_CAT+:} false; then :
5636   $as_echo_n "(cached) " >&6
5637 else
5638   case $CAT in
5639   [\\/]* | ?:[\\/]*)
5640   ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
5641   ;;
5642   *)
5643   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5644 for as_dir in $PATH
5645 do
5646   IFS=$as_save_IFS
5647   test -z "$as_dir" && as_dir=.
5648     for ac_exec_ext in '' $ac_executable_extensions; do
5649   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5650     ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
5651     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5652     break 2
5653   fi
5654 done
5655   done
5656 IFS=$as_save_IFS
5657 
5658   ;;
5659 esac
5660 fi
5661 CAT=$ac_cv_path_CAT
5662 if test -n "$CAT"; then
5663   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
5664 $as_echo "$CAT" >&6; }
5665 else
5666   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5667 $as_echo "no" >&6; }
5668 fi
5669 
5670 
5671   test -n "$CAT" && break
5672 done
5673 
5674     else
5675       # If it succeeded, then it was overridden by the user. We will use it
5676       # for the tool.
5677 
5678       # First remove it from the list of overridden variables, so we can test
5679       # for unknown variables in the end.
5680       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5681 
5682       # Check if we try to supply an empty value
5683       if test "x$CAT" = x; then
5684         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CAT= (no value)" >&5
5685 $as_echo "$as_me: Setting user supplied tool CAT= (no value)" >&6;}
5686         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CAT" >&5
5687 $as_echo_n "checking for CAT... " >&6; }
5688         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
5689 $as_echo "disabled" >&6; }
5690       else
5691         # Check if the provided tool contains a complete path.
5692         tool_specified="$CAT"
5693         tool_basename="${tool_specified##*/}"
5694         if test "x$tool_basename" = "x$tool_specified"; then
5695           # A command without a complete path is provided, search $PATH.
5696           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CAT=$tool_basename" >&5
5697 $as_echo "$as_me: Will search for user supplied tool CAT=$tool_basename" >&6;}
5698           # Extract the first word of "$tool_basename", so it can be a program name with args.
5699 set dummy $tool_basename; ac_word=$2
5700 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5701 $as_echo_n "checking for $ac_word... " >&6; }
5702 if ${ac_cv_path_CAT+:} false; then :
5703   $as_echo_n "(cached) " >&6
5704 else
5705   case $CAT in
5706   [\\/]* | ?:[\\/]*)
5707   ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
5708   ;;
5709   *)
5710   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5711 for as_dir in $PATH
5712 do
5713   IFS=$as_save_IFS
5714   test -z "$as_dir" && as_dir=.
5715     for ac_exec_ext in '' $ac_executable_extensions; do
5716   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5717     ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
5718     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5719     break 2
5720   fi
5721 done
5722   done
5723 IFS=$as_save_IFS
5724 
5725   ;;
5726 esac
5727 fi
5728 CAT=$ac_cv_path_CAT
5729 if test -n "$CAT"; then
5730   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
5731 $as_echo "$CAT" >&6; }
5732 else
5733   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5734 $as_echo "no" >&6; }
5735 fi
5736 
5737 
5738           if test "x$CAT" = x; then
5739             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5740           fi
5741         else
5742           # Otherwise we believe it is a complete path. Use it as it is.
5743           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CAT=$tool_specified" >&5
5744 $as_echo "$as_me: Will use user supplied tool CAT=$tool_specified" >&6;}
5745           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CAT" >&5
5746 $as_echo_n "checking for CAT... " >&6; }
5747           if test ! -x "$tool_specified"; then
5748             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5749 $as_echo "not found" >&6; }
5750             as_fn_error $? "User supplied tool CAT=$tool_specified does not exist or is not executable" "$LINENO" 5
5751           fi
5752           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5753 $as_echo "$tool_specified" >&6; }
5754         fi
5755       fi
5756     fi
5757 
5758   fi
5759 
5760 
5761 
5762   if test "x$CAT" = x; then
5763     as_fn_error $? "Could not find required tool for CAT" "$LINENO" 5
5764   fi
5765 
5766 
5767 
5768 
5769 
5770   # Publish this variable in the help.
5771 
5772 
5773   if [ -z "${CHMOD+x}" ]; then
5774     # The variable is not set by user, try to locate tool using the code snippet
5775     for ac_prog in chmod
5776 do
5777   # Extract the first word of "$ac_prog", so it can be a program name with args.
5778 set dummy $ac_prog; ac_word=$2
5779 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5780 $as_echo_n "checking for $ac_word... " >&6; }
5781 if ${ac_cv_path_CHMOD+:} false; then :
5782   $as_echo_n "(cached) " >&6
5783 else
5784   case $CHMOD in
5785   [\\/]* | ?:[\\/]*)
5786   ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
5787   ;;
5788   *)
5789   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5790 for as_dir in $PATH
5791 do
5792   IFS=$as_save_IFS
5793   test -z "$as_dir" && as_dir=.
5794     for ac_exec_ext in '' $ac_executable_extensions; do
5795   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5796     ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
5797     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5798     break 2
5799   fi
5800 done
5801   done
5802 IFS=$as_save_IFS
5803 
5804   ;;
5805 esac
5806 fi
5807 CHMOD=$ac_cv_path_CHMOD
5808 if test -n "$CHMOD"; then
5809   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
5810 $as_echo "$CHMOD" >&6; }
5811 else
5812   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5813 $as_echo "no" >&6; }
5814 fi
5815 
5816 
5817   test -n "$CHMOD" && break
5818 done
5819 
5820   else
5821     # The variable is set, but is it from the command line or the environment?
5822 
5823     # Try to remove the string !CHMOD! from our list.
5824     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CHMOD!/}
5825     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5826       # If it failed, the variable was not from the command line. Ignore it,
5827       # but warn the user (except for BASH, which is always set by the calling BASH).
5828       if test "xCHMOD" != xBASH; then
5829         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CHMOD from the environment. Use command line variables instead." >&5
5830 $as_echo "$as_me: WARNING: Ignoring value of CHMOD from the environment. Use command line variables instead." >&2;}
5831       fi
5832       # Try to locate tool using the code snippet
5833       for ac_prog in chmod
5834 do
5835   # Extract the first word of "$ac_prog", so it can be a program name with args.
5836 set dummy $ac_prog; ac_word=$2
5837 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5838 $as_echo_n "checking for $ac_word... " >&6; }
5839 if ${ac_cv_path_CHMOD+:} false; then :
5840   $as_echo_n "(cached) " >&6
5841 else
5842   case $CHMOD in
5843   [\\/]* | ?:[\\/]*)
5844   ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
5845   ;;
5846   *)
5847   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5848 for as_dir in $PATH
5849 do
5850   IFS=$as_save_IFS
5851   test -z "$as_dir" && as_dir=.
5852     for ac_exec_ext in '' $ac_executable_extensions; do
5853   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5854     ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
5855     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5856     break 2
5857   fi
5858 done
5859   done
5860 IFS=$as_save_IFS
5861 
5862   ;;
5863 esac
5864 fi
5865 CHMOD=$ac_cv_path_CHMOD
5866 if test -n "$CHMOD"; then
5867   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
5868 $as_echo "$CHMOD" >&6; }
5869 else
5870   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5871 $as_echo "no" >&6; }
5872 fi
5873 
5874 
5875   test -n "$CHMOD" && break
5876 done
5877 
5878     else
5879       # If it succeeded, then it was overridden by the user. We will use it
5880       # for the tool.
5881 
5882       # First remove it from the list of overridden variables, so we can test
5883       # for unknown variables in the end.
5884       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5885 
5886       # Check if we try to supply an empty value
5887       if test "x$CHMOD" = x; then
5888         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CHMOD= (no value)" >&5
5889 $as_echo "$as_me: Setting user supplied tool CHMOD= (no value)" >&6;}
5890         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CHMOD" >&5
5891 $as_echo_n "checking for CHMOD... " >&6; }
5892         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
5893 $as_echo "disabled" >&6; }
5894       else
5895         # Check if the provided tool contains a complete path.
5896         tool_specified="$CHMOD"
5897         tool_basename="${tool_specified##*/}"
5898         if test "x$tool_basename" = "x$tool_specified"; then
5899           # A command without a complete path is provided, search $PATH.
5900           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CHMOD=$tool_basename" >&5
5901 $as_echo "$as_me: Will search for user supplied tool CHMOD=$tool_basename" >&6;}
5902           # Extract the first word of "$tool_basename", so it can be a program name with args.
5903 set dummy $tool_basename; ac_word=$2
5904 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5905 $as_echo_n "checking for $ac_word... " >&6; }
5906 if ${ac_cv_path_CHMOD+:} false; then :
5907   $as_echo_n "(cached) " >&6
5908 else
5909   case $CHMOD in
5910   [\\/]* | ?:[\\/]*)
5911   ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
5912   ;;
5913   *)
5914   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5915 for as_dir in $PATH
5916 do
5917   IFS=$as_save_IFS
5918   test -z "$as_dir" && as_dir=.
5919     for ac_exec_ext in '' $ac_executable_extensions; do
5920   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5921     ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
5922     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5923     break 2
5924   fi
5925 done
5926   done
5927 IFS=$as_save_IFS
5928 
5929   ;;
5930 esac
5931 fi
5932 CHMOD=$ac_cv_path_CHMOD
5933 if test -n "$CHMOD"; then
5934   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
5935 $as_echo "$CHMOD" >&6; }
5936 else
5937   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5938 $as_echo "no" >&6; }
5939 fi
5940 
5941 
5942           if test "x$CHMOD" = x; then
5943             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5944           fi
5945         else
5946           # Otherwise we believe it is a complete path. Use it as it is.
5947           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CHMOD=$tool_specified" >&5
5948 $as_echo "$as_me: Will use user supplied tool CHMOD=$tool_specified" >&6;}
5949           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CHMOD" >&5
5950 $as_echo_n "checking for CHMOD... " >&6; }
5951           if test ! -x "$tool_specified"; then
5952             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5953 $as_echo "not found" >&6; }
5954             as_fn_error $? "User supplied tool CHMOD=$tool_specified does not exist or is not executable" "$LINENO" 5
5955           fi
5956           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5957 $as_echo "$tool_specified" >&6; }
5958         fi
5959       fi
5960     fi
5961 
5962   fi
5963 
5964 
5965 
5966   if test "x$CHMOD" = x; then
5967     as_fn_error $? "Could not find required tool for CHMOD" "$LINENO" 5
5968   fi
5969 
5970 
5971 
5972 
5973 
5974   # Publish this variable in the help.
5975 
5976 
5977   if [ -z "${CMP+x}" ]; then
5978     # The variable is not set by user, try to locate tool using the code snippet
5979     for ac_prog in cmp
5980 do
5981   # Extract the first word of "$ac_prog", so it can be a program name with args.
5982 set dummy $ac_prog; ac_word=$2
5983 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5984 $as_echo_n "checking for $ac_word... " >&6; }
5985 if ${ac_cv_path_CMP+:} false; then :
5986   $as_echo_n "(cached) " >&6
5987 else
5988   case $CMP in
5989   [\\/]* | ?:[\\/]*)
5990   ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
5991   ;;
5992   *)
5993   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5994 for as_dir in $PATH
5995 do
5996   IFS=$as_save_IFS
5997   test -z "$as_dir" && as_dir=.
5998     for ac_exec_ext in '' $ac_executable_extensions; do
5999   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6000     ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
6001     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6002     break 2
6003   fi
6004 done
6005   done
6006 IFS=$as_save_IFS
6007 
6008   ;;
6009 esac
6010 fi
6011 CMP=$ac_cv_path_CMP
6012 if test -n "$CMP"; then
6013   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
6014 $as_echo "$CMP" >&6; }
6015 else
6016   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6017 $as_echo "no" >&6; }
6018 fi
6019 
6020 
6021   test -n "$CMP" && break
6022 done
6023 
6024   else
6025     # The variable is set, but is it from the command line or the environment?
6026 
6027     # Try to remove the string !CMP! from our list.
6028     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CMP!/}
6029     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6030       # If it failed, the variable was not from the command line. Ignore it,
6031       # but warn the user (except for BASH, which is always set by the calling BASH).
6032       if test "xCMP" != xBASH; then
6033         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CMP from the environment. Use command line variables instead." >&5
6034 $as_echo "$as_me: WARNING: Ignoring value of CMP from the environment. Use command line variables instead." >&2;}
6035       fi
6036       # Try to locate tool using the code snippet
6037       for ac_prog in cmp
6038 do
6039   # Extract the first word of "$ac_prog", so it can be a program name with args.
6040 set dummy $ac_prog; ac_word=$2
6041 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6042 $as_echo_n "checking for $ac_word... " >&6; }
6043 if ${ac_cv_path_CMP+:} false; then :
6044   $as_echo_n "(cached) " >&6
6045 else
6046   case $CMP in
6047   [\\/]* | ?:[\\/]*)
6048   ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
6049   ;;
6050   *)
6051   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6052 for as_dir in $PATH
6053 do
6054   IFS=$as_save_IFS
6055   test -z "$as_dir" && as_dir=.
6056     for ac_exec_ext in '' $ac_executable_extensions; do
6057   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6058     ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
6059     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6060     break 2
6061   fi
6062 done
6063   done
6064 IFS=$as_save_IFS
6065 
6066   ;;
6067 esac
6068 fi
6069 CMP=$ac_cv_path_CMP
6070 if test -n "$CMP"; then
6071   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
6072 $as_echo "$CMP" >&6; }
6073 else
6074   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6075 $as_echo "no" >&6; }
6076 fi
6077 
6078 
6079   test -n "$CMP" && break
6080 done
6081 
6082     else
6083       # If it succeeded, then it was overridden by the user. We will use it
6084       # for the tool.
6085 
6086       # First remove it from the list of overridden variables, so we can test
6087       # for unknown variables in the end.
6088       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6089 
6090       # Check if we try to supply an empty value
6091       if test "x$CMP" = x; then
6092         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CMP= (no value)" >&5
6093 $as_echo "$as_me: Setting user supplied tool CMP= (no value)" >&6;}
6094         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CMP" >&5
6095 $as_echo_n "checking for CMP... " >&6; }
6096         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
6097 $as_echo "disabled" >&6; }
6098       else
6099         # Check if the provided tool contains a complete path.
6100         tool_specified="$CMP"
6101         tool_basename="${tool_specified##*/}"
6102         if test "x$tool_basename" = "x$tool_specified"; then
6103           # A command without a complete path is provided, search $PATH.
6104           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CMP=$tool_basename" >&5
6105 $as_echo "$as_me: Will search for user supplied tool CMP=$tool_basename" >&6;}
6106           # Extract the first word of "$tool_basename", so it can be a program name with args.
6107 set dummy $tool_basename; ac_word=$2
6108 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6109 $as_echo_n "checking for $ac_word... " >&6; }
6110 if ${ac_cv_path_CMP+:} false; then :
6111   $as_echo_n "(cached) " >&6
6112 else
6113   case $CMP in
6114   [\\/]* | ?:[\\/]*)
6115   ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
6116   ;;
6117   *)
6118   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6119 for as_dir in $PATH
6120 do
6121   IFS=$as_save_IFS
6122   test -z "$as_dir" && as_dir=.
6123     for ac_exec_ext in '' $ac_executable_extensions; do
6124   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6125     ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
6126     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6127     break 2
6128   fi
6129 done
6130   done
6131 IFS=$as_save_IFS
6132 
6133   ;;
6134 esac
6135 fi
6136 CMP=$ac_cv_path_CMP
6137 if test -n "$CMP"; then
6138   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
6139 $as_echo "$CMP" >&6; }
6140 else
6141   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6142 $as_echo "no" >&6; }
6143 fi
6144 
6145 
6146           if test "x$CMP" = x; then
6147             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6148           fi
6149         else
6150           # Otherwise we believe it is a complete path. Use it as it is.
6151           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CMP=$tool_specified" >&5
6152 $as_echo "$as_me: Will use user supplied tool CMP=$tool_specified" >&6;}
6153           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CMP" >&5
6154 $as_echo_n "checking for CMP... " >&6; }
6155           if test ! -x "$tool_specified"; then
6156             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6157 $as_echo "not found" >&6; }
6158             as_fn_error $? "User supplied tool CMP=$tool_specified does not exist or is not executable" "$LINENO" 5
6159           fi
6160           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6161 $as_echo "$tool_specified" >&6; }
6162         fi
6163       fi
6164     fi
6165 
6166   fi
6167 
6168 
6169 
6170   if test "x$CMP" = x; then
6171     as_fn_error $? "Could not find required tool for CMP" "$LINENO" 5
6172   fi
6173 
6174 
6175 
6176 
6177 
6178   # Publish this variable in the help.
6179 
6180 
6181   if [ -z "${COMM+x}" ]; then
6182     # The variable is not set by user, try to locate tool using the code snippet
6183     for ac_prog in comm
6184 do
6185   # Extract the first word of "$ac_prog", so it can be a program name with args.
6186 set dummy $ac_prog; ac_word=$2
6187 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6188 $as_echo_n "checking for $ac_word... " >&6; }
6189 if ${ac_cv_path_COMM+:} false; then :
6190   $as_echo_n "(cached) " >&6
6191 else
6192   case $COMM in
6193   [\\/]* | ?:[\\/]*)
6194   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
6195   ;;
6196   *)
6197   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6198 for as_dir in $PATH
6199 do
6200   IFS=$as_save_IFS
6201   test -z "$as_dir" && as_dir=.
6202     for ac_exec_ext in '' $ac_executable_extensions; do
6203   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6204     ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
6205     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6206     break 2
6207   fi
6208 done
6209   done
6210 IFS=$as_save_IFS
6211 
6212   ;;
6213 esac
6214 fi
6215 COMM=$ac_cv_path_COMM
6216 if test -n "$COMM"; then
6217   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
6218 $as_echo "$COMM" >&6; }
6219 else
6220   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6221 $as_echo "no" >&6; }
6222 fi
6223 
6224 
6225   test -n "$COMM" && break
6226 done
6227 
6228   else
6229     # The variable is set, but is it from the command line or the environment?
6230 
6231     # Try to remove the string !COMM! from our list.
6232     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!COMM!/}
6233     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6234       # If it failed, the variable was not from the command line. Ignore it,
6235       # but warn the user (except for BASH, which is always set by the calling BASH).
6236       if test "xCOMM" != xBASH; then
6237         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&5
6238 $as_echo "$as_me: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&2;}
6239       fi
6240       # Try to locate tool using the code snippet
6241       for ac_prog in comm
6242 do
6243   # Extract the first word of "$ac_prog", so it can be a program name with args.
6244 set dummy $ac_prog; ac_word=$2
6245 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6246 $as_echo_n "checking for $ac_word... " >&6; }
6247 if ${ac_cv_path_COMM+:} false; then :
6248   $as_echo_n "(cached) " >&6
6249 else
6250   case $COMM in
6251   [\\/]* | ?:[\\/]*)
6252   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
6253   ;;
6254   *)
6255   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6256 for as_dir in $PATH
6257 do
6258   IFS=$as_save_IFS
6259   test -z "$as_dir" && as_dir=.
6260     for ac_exec_ext in '' $ac_executable_extensions; do
6261   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6262     ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
6263     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6264     break 2
6265   fi
6266 done
6267   done
6268 IFS=$as_save_IFS
6269 
6270   ;;
6271 esac
6272 fi
6273 COMM=$ac_cv_path_COMM
6274 if test -n "$COMM"; then
6275   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
6276 $as_echo "$COMM" >&6; }
6277 else
6278   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6279 $as_echo "no" >&6; }
6280 fi
6281 
6282 
6283   test -n "$COMM" && break
6284 done
6285 
6286     else
6287       # If it succeeded, then it was overridden by the user. We will use it
6288       # for the tool.
6289 
6290       # First remove it from the list of overridden variables, so we can test
6291       # for unknown variables in the end.
6292       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6293 
6294       # Check if we try to supply an empty value
6295       if test "x$COMM" = x; then
6296         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool COMM= (no value)" >&5
6297 $as_echo "$as_me: Setting user supplied tool COMM= (no value)" >&6;}
6298         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for COMM" >&5
6299 $as_echo_n "checking for COMM... " >&6; }
6300         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
6301 $as_echo "disabled" >&6; }
6302       else
6303         # Check if the provided tool contains a complete path.
6304         tool_specified="$COMM"
6305         tool_basename="${tool_specified##*/}"
6306         if test "x$tool_basename" = "x$tool_specified"; then
6307           # A command without a complete path is provided, search $PATH.
6308           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool COMM=$tool_basename" >&5
6309 $as_echo "$as_me: Will search for user supplied tool COMM=$tool_basename" >&6;}
6310           # Extract the first word of "$tool_basename", so it can be a program name with args.
6311 set dummy $tool_basename; ac_word=$2
6312 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6313 $as_echo_n "checking for $ac_word... " >&6; }
6314 if ${ac_cv_path_COMM+:} false; then :
6315   $as_echo_n "(cached) " >&6
6316 else
6317   case $COMM in
6318   [\\/]* | ?:[\\/]*)
6319   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
6320   ;;
6321   *)
6322   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6323 for as_dir in $PATH
6324 do
6325   IFS=$as_save_IFS
6326   test -z "$as_dir" && as_dir=.
6327     for ac_exec_ext in '' $ac_executable_extensions; do
6328   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6329     ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
6330     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6331     break 2
6332   fi
6333 done
6334   done
6335 IFS=$as_save_IFS
6336 
6337   ;;
6338 esac
6339 fi
6340 COMM=$ac_cv_path_COMM
6341 if test -n "$COMM"; then
6342   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
6343 $as_echo "$COMM" >&6; }
6344 else
6345   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6346 $as_echo "no" >&6; }
6347 fi
6348 
6349 
6350           if test "x$COMM" = x; then
6351             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6352           fi
6353         else
6354           # Otherwise we believe it is a complete path. Use it as it is.
6355           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool COMM=$tool_specified" >&5
6356 $as_echo "$as_me: Will use user supplied tool COMM=$tool_specified" >&6;}
6357           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for COMM" >&5
6358 $as_echo_n "checking for COMM... " >&6; }
6359           if test ! -x "$tool_specified"; then
6360             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6361 $as_echo "not found" >&6; }
6362             as_fn_error $? "User supplied tool COMM=$tool_specified does not exist or is not executable" "$LINENO" 5
6363           fi
6364           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6365 $as_echo "$tool_specified" >&6; }
6366         fi
6367       fi
6368     fi
6369 
6370   fi
6371 
6372 
6373 
6374   if test "x$COMM" = x; then
6375     as_fn_error $? "Could not find required tool for COMM" "$LINENO" 5
6376   fi
6377 
6378 
6379 
6380 
6381 
6382   # Publish this variable in the help.
6383 
6384 
6385   if [ -z "${CP+x}" ]; then
6386     # The variable is not set by user, try to locate tool using the code snippet
6387     for ac_prog in cp
6388 do
6389   # Extract the first word of "$ac_prog", so it can be a program name with args.
6390 set dummy $ac_prog; ac_word=$2
6391 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6392 $as_echo_n "checking for $ac_word... " >&6; }
6393 if ${ac_cv_path_CP+:} false; then :
6394   $as_echo_n "(cached) " >&6
6395 else
6396   case $CP in
6397   [\\/]* | ?:[\\/]*)
6398   ac_cv_path_CP="$CP" # Let the user override the test with a path.
6399   ;;
6400   *)
6401   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6402 for as_dir in $PATH
6403 do
6404   IFS=$as_save_IFS
6405   test -z "$as_dir" && as_dir=.
6406     for ac_exec_ext in '' $ac_executable_extensions; do
6407   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6408     ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
6409     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6410     break 2
6411   fi
6412 done
6413   done
6414 IFS=$as_save_IFS
6415 
6416   ;;
6417 esac
6418 fi
6419 CP=$ac_cv_path_CP
6420 if test -n "$CP"; then
6421   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
6422 $as_echo "$CP" >&6; }
6423 else
6424   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6425 $as_echo "no" >&6; }
6426 fi
6427 
6428 
6429   test -n "$CP" && break
6430 done
6431 
6432   else
6433     # The variable is set, but is it from the command line or the environment?
6434 
6435     # Try to remove the string !CP! from our list.
6436     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CP!/}
6437     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6438       # If it failed, the variable was not from the command line. Ignore it,
6439       # but warn the user (except for BASH, which is always set by the calling BASH).
6440       if test "xCP" != xBASH; then
6441         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CP from the environment. Use command line variables instead." >&5
6442 $as_echo "$as_me: WARNING: Ignoring value of CP from the environment. Use command line variables instead." >&2;}
6443       fi
6444       # Try to locate tool using the code snippet
6445       for ac_prog in cp
6446 do
6447   # Extract the first word of "$ac_prog", so it can be a program name with args.
6448 set dummy $ac_prog; ac_word=$2
6449 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6450 $as_echo_n "checking for $ac_word... " >&6; }
6451 if ${ac_cv_path_CP+:} false; then :
6452   $as_echo_n "(cached) " >&6
6453 else
6454   case $CP in
6455   [\\/]* | ?:[\\/]*)
6456   ac_cv_path_CP="$CP" # Let the user override the test with a path.
6457   ;;
6458   *)
6459   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6460 for as_dir in $PATH
6461 do
6462   IFS=$as_save_IFS
6463   test -z "$as_dir" && as_dir=.
6464     for ac_exec_ext in '' $ac_executable_extensions; do
6465   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6466     ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
6467     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6468     break 2
6469   fi
6470 done
6471   done
6472 IFS=$as_save_IFS
6473 
6474   ;;
6475 esac
6476 fi
6477 CP=$ac_cv_path_CP
6478 if test -n "$CP"; then
6479   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
6480 $as_echo "$CP" >&6; }
6481 else
6482   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6483 $as_echo "no" >&6; }
6484 fi
6485 
6486 
6487   test -n "$CP" && break
6488 done
6489 
6490     else
6491       # If it succeeded, then it was overridden by the user. We will use it
6492       # for the tool.
6493 
6494       # First remove it from the list of overridden variables, so we can test
6495       # for unknown variables in the end.
6496       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6497 
6498       # Check if we try to supply an empty value
6499       if test "x$CP" = x; then
6500         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CP= (no value)" >&5
6501 $as_echo "$as_me: Setting user supplied tool CP= (no value)" >&6;}
6502         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CP" >&5
6503 $as_echo_n "checking for CP... " >&6; }
6504         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
6505 $as_echo "disabled" >&6; }
6506       else
6507         # Check if the provided tool contains a complete path.
6508         tool_specified="$CP"
6509         tool_basename="${tool_specified##*/}"
6510         if test "x$tool_basename" = "x$tool_specified"; then
6511           # A command without a complete path is provided, search $PATH.
6512           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CP=$tool_basename" >&5
6513 $as_echo "$as_me: Will search for user supplied tool CP=$tool_basename" >&6;}
6514           # Extract the first word of "$tool_basename", so it can be a program name with args.
6515 set dummy $tool_basename; ac_word=$2
6516 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6517 $as_echo_n "checking for $ac_word... " >&6; }
6518 if ${ac_cv_path_CP+:} false; then :
6519   $as_echo_n "(cached) " >&6
6520 else
6521   case $CP in
6522   [\\/]* | ?:[\\/]*)
6523   ac_cv_path_CP="$CP" # Let the user override the test with a path.
6524   ;;
6525   *)
6526   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6527 for as_dir in $PATH
6528 do
6529   IFS=$as_save_IFS
6530   test -z "$as_dir" && as_dir=.
6531     for ac_exec_ext in '' $ac_executable_extensions; do
6532   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6533     ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
6534     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6535     break 2
6536   fi
6537 done
6538   done
6539 IFS=$as_save_IFS
6540 
6541   ;;
6542 esac
6543 fi
6544 CP=$ac_cv_path_CP
6545 if test -n "$CP"; then
6546   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
6547 $as_echo "$CP" >&6; }
6548 else
6549   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6550 $as_echo "no" >&6; }
6551 fi
6552 
6553 
6554           if test "x$CP" = x; then
6555             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6556           fi
6557         else
6558           # Otherwise we believe it is a complete path. Use it as it is.
6559           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CP=$tool_specified" >&5
6560 $as_echo "$as_me: Will use user supplied tool CP=$tool_specified" >&6;}
6561           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CP" >&5
6562 $as_echo_n "checking for CP... " >&6; }
6563           if test ! -x "$tool_specified"; then
6564             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6565 $as_echo "not found" >&6; }
6566             as_fn_error $? "User supplied tool CP=$tool_specified does not exist or is not executable" "$LINENO" 5
6567           fi
6568           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6569 $as_echo "$tool_specified" >&6; }
6570         fi
6571       fi
6572     fi
6573 
6574   fi
6575 
6576 
6577 
6578   if test "x$CP" = x; then
6579     as_fn_error $? "Could not find required tool for CP" "$LINENO" 5
6580   fi
6581 
6582 
6583 
6584 
6585 
6586   # Publish this variable in the help.
6587 
6588 
6589   if [ -z "${CUT+x}" ]; then
6590     # The variable is not set by user, try to locate tool using the code snippet
6591     for ac_prog in cut
6592 do
6593   # Extract the first word of "$ac_prog", so it can be a program name with args.
6594 set dummy $ac_prog; ac_word=$2
6595 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6596 $as_echo_n "checking for $ac_word... " >&6; }
6597 if ${ac_cv_path_CUT+:} false; then :
6598   $as_echo_n "(cached) " >&6
6599 else
6600   case $CUT in
6601   [\\/]* | ?:[\\/]*)
6602   ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
6603   ;;
6604   *)
6605   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6606 for as_dir in $PATH
6607 do
6608   IFS=$as_save_IFS
6609   test -z "$as_dir" && as_dir=.
6610     for ac_exec_ext in '' $ac_executable_extensions; do
6611   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6612     ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
6613     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6614     break 2
6615   fi
6616 done
6617   done
6618 IFS=$as_save_IFS
6619 
6620   ;;
6621 esac
6622 fi
6623 CUT=$ac_cv_path_CUT
6624 if test -n "$CUT"; then
6625   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
6626 $as_echo "$CUT" >&6; }
6627 else
6628   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6629 $as_echo "no" >&6; }
6630 fi
6631 
6632 
6633   test -n "$CUT" && break
6634 done
6635 
6636   else
6637     # The variable is set, but is it from the command line or the environment?
6638 
6639     # Try to remove the string !CUT! from our list.
6640     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CUT!/}
6641     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6642       # If it failed, the variable was not from the command line. Ignore it,
6643       # but warn the user (except for BASH, which is always set by the calling BASH).
6644       if test "xCUT" != xBASH; then
6645         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CUT from the environment. Use command line variables instead." >&5
6646 $as_echo "$as_me: WARNING: Ignoring value of CUT from the environment. Use command line variables instead." >&2;}
6647       fi
6648       # Try to locate tool using the code snippet
6649       for ac_prog in cut
6650 do
6651   # Extract the first word of "$ac_prog", so it can be a program name with args.
6652 set dummy $ac_prog; ac_word=$2
6653 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6654 $as_echo_n "checking for $ac_word... " >&6; }
6655 if ${ac_cv_path_CUT+:} false; then :
6656   $as_echo_n "(cached) " >&6
6657 else
6658   case $CUT in
6659   [\\/]* | ?:[\\/]*)
6660   ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
6661   ;;
6662   *)
6663   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6664 for as_dir in $PATH
6665 do
6666   IFS=$as_save_IFS
6667   test -z "$as_dir" && as_dir=.
6668     for ac_exec_ext in '' $ac_executable_extensions; do
6669   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6670     ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
6671     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6672     break 2
6673   fi
6674 done
6675   done
6676 IFS=$as_save_IFS
6677 
6678   ;;
6679 esac
6680 fi
6681 CUT=$ac_cv_path_CUT
6682 if test -n "$CUT"; then
6683   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
6684 $as_echo "$CUT" >&6; }
6685 else
6686   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6687 $as_echo "no" >&6; }
6688 fi
6689 
6690 
6691   test -n "$CUT" && break
6692 done
6693 
6694     else
6695       # If it succeeded, then it was overridden by the user. We will use it
6696       # for the tool.
6697 
6698       # First remove it from the list of overridden variables, so we can test
6699       # for unknown variables in the end.
6700       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6701 
6702       # Check if we try to supply an empty value
6703       if test "x$CUT" = x; then
6704         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CUT= (no value)" >&5
6705 $as_echo "$as_me: Setting user supplied tool CUT= (no value)" >&6;}
6706         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CUT" >&5
6707 $as_echo_n "checking for CUT... " >&6; }
6708         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
6709 $as_echo "disabled" >&6; }
6710       else
6711         # Check if the provided tool contains a complete path.
6712         tool_specified="$CUT"
6713         tool_basename="${tool_specified##*/}"
6714         if test "x$tool_basename" = "x$tool_specified"; then
6715           # A command without a complete path is provided, search $PATH.
6716           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CUT=$tool_basename" >&5
6717 $as_echo "$as_me: Will search for user supplied tool CUT=$tool_basename" >&6;}
6718           # Extract the first word of "$tool_basename", so it can be a program name with args.
6719 set dummy $tool_basename; ac_word=$2
6720 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6721 $as_echo_n "checking for $ac_word... " >&6; }
6722 if ${ac_cv_path_CUT+:} false; then :
6723   $as_echo_n "(cached) " >&6
6724 else
6725   case $CUT in
6726   [\\/]* | ?:[\\/]*)
6727   ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
6728   ;;
6729   *)
6730   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6731 for as_dir in $PATH
6732 do
6733   IFS=$as_save_IFS
6734   test -z "$as_dir" && as_dir=.
6735     for ac_exec_ext in '' $ac_executable_extensions; do
6736   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6737     ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
6738     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6739     break 2
6740   fi
6741 done
6742   done
6743 IFS=$as_save_IFS
6744 
6745   ;;
6746 esac
6747 fi
6748 CUT=$ac_cv_path_CUT
6749 if test -n "$CUT"; then
6750   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
6751 $as_echo "$CUT" >&6; }
6752 else
6753   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6754 $as_echo "no" >&6; }
6755 fi
6756 
6757 
6758           if test "x$CUT" = x; then
6759             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6760           fi
6761         else
6762           # Otherwise we believe it is a complete path. Use it as it is.
6763           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CUT=$tool_specified" >&5
6764 $as_echo "$as_me: Will use user supplied tool CUT=$tool_specified" >&6;}
6765           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CUT" >&5
6766 $as_echo_n "checking for CUT... " >&6; }
6767           if test ! -x "$tool_specified"; then
6768             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6769 $as_echo "not found" >&6; }
6770             as_fn_error $? "User supplied tool CUT=$tool_specified does not exist or is not executable" "$LINENO" 5
6771           fi
6772           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6773 $as_echo "$tool_specified" >&6; }
6774         fi
6775       fi
6776     fi
6777 
6778   fi
6779 
6780 
6781 
6782   if test "x$CUT" = x; then
6783     as_fn_error $? "Could not find required tool for CUT" "$LINENO" 5
6784   fi
6785 
6786 
6787 
6788 
6789 
6790   # Publish this variable in the help.
6791 
6792 
6793   if [ -z "${DATE+x}" ]; then
6794     # The variable is not set by user, try to locate tool using the code snippet
6795     for ac_prog in date
6796 do
6797   # Extract the first word of "$ac_prog", so it can be a program name with args.
6798 set dummy $ac_prog; ac_word=$2
6799 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6800 $as_echo_n "checking for $ac_word... " >&6; }
6801 if ${ac_cv_path_DATE+:} false; then :
6802   $as_echo_n "(cached) " >&6
6803 else
6804   case $DATE in
6805   [\\/]* | ?:[\\/]*)
6806   ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
6807   ;;
6808   *)
6809   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6810 for as_dir in $PATH
6811 do
6812   IFS=$as_save_IFS
6813   test -z "$as_dir" && as_dir=.
6814     for ac_exec_ext in '' $ac_executable_extensions; do
6815   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6816     ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
6817     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6818     break 2
6819   fi
6820 done
6821   done
6822 IFS=$as_save_IFS
6823 
6824   ;;
6825 esac
6826 fi
6827 DATE=$ac_cv_path_DATE
6828 if test -n "$DATE"; then
6829   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
6830 $as_echo "$DATE" >&6; }
6831 else
6832   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6833 $as_echo "no" >&6; }
6834 fi
6835 
6836 
6837   test -n "$DATE" && break
6838 done
6839 
6840   else
6841     # The variable is set, but is it from the command line or the environment?
6842 
6843     # Try to remove the string !DATE! from our list.
6844     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DATE!/}
6845     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6846       # If it failed, the variable was not from the command line. Ignore it,
6847       # but warn the user (except for BASH, which is always set by the calling BASH).
6848       if test "xDATE" != xBASH; then
6849         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DATE from the environment. Use command line variables instead." >&5
6850 $as_echo "$as_me: WARNING: Ignoring value of DATE from the environment. Use command line variables instead." >&2;}
6851       fi
6852       # Try to locate tool using the code snippet
6853       for ac_prog in date
6854 do
6855   # Extract the first word of "$ac_prog", so it can be a program name with args.
6856 set dummy $ac_prog; ac_word=$2
6857 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6858 $as_echo_n "checking for $ac_word... " >&6; }
6859 if ${ac_cv_path_DATE+:} false; then :
6860   $as_echo_n "(cached) " >&6
6861 else
6862   case $DATE in
6863   [\\/]* | ?:[\\/]*)
6864   ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
6865   ;;
6866   *)
6867   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6868 for as_dir in $PATH
6869 do
6870   IFS=$as_save_IFS
6871   test -z "$as_dir" && as_dir=.
6872     for ac_exec_ext in '' $ac_executable_extensions; do
6873   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6874     ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
6875     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6876     break 2
6877   fi
6878 done
6879   done
6880 IFS=$as_save_IFS
6881 
6882   ;;
6883 esac
6884 fi
6885 DATE=$ac_cv_path_DATE
6886 if test -n "$DATE"; then
6887   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
6888 $as_echo "$DATE" >&6; }
6889 else
6890   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6891 $as_echo "no" >&6; }
6892 fi
6893 
6894 
6895   test -n "$DATE" && break
6896 done
6897 
6898     else
6899       # If it succeeded, then it was overridden by the user. We will use it
6900       # for the tool.
6901 
6902       # First remove it from the list of overridden variables, so we can test
6903       # for unknown variables in the end.
6904       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6905 
6906       # Check if we try to supply an empty value
6907       if test "x$DATE" = x; then
6908         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool DATE= (no value)" >&5
6909 $as_echo "$as_me: Setting user supplied tool DATE= (no value)" >&6;}
6910         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DATE" >&5
6911 $as_echo_n "checking for DATE... " >&6; }
6912         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
6913 $as_echo "disabled" >&6; }
6914       else
6915         # Check if the provided tool contains a complete path.
6916         tool_specified="$DATE"
6917         tool_basename="${tool_specified##*/}"
6918         if test "x$tool_basename" = "x$tool_specified"; then
6919           # A command without a complete path is provided, search $PATH.
6920           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DATE=$tool_basename" >&5
6921 $as_echo "$as_me: Will search for user supplied tool DATE=$tool_basename" >&6;}
6922           # Extract the first word of "$tool_basename", so it can be a program name with args.
6923 set dummy $tool_basename; ac_word=$2
6924 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6925 $as_echo_n "checking for $ac_word... " >&6; }
6926 if ${ac_cv_path_DATE+:} false; then :
6927   $as_echo_n "(cached) " >&6
6928 else
6929   case $DATE in
6930   [\\/]* | ?:[\\/]*)
6931   ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
6932   ;;
6933   *)
6934   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6935 for as_dir in $PATH
6936 do
6937   IFS=$as_save_IFS
6938   test -z "$as_dir" && as_dir=.
6939     for ac_exec_ext in '' $ac_executable_extensions; do
6940   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6941     ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
6942     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6943     break 2
6944   fi
6945 done
6946   done
6947 IFS=$as_save_IFS
6948 
6949   ;;
6950 esac
6951 fi
6952 DATE=$ac_cv_path_DATE
6953 if test -n "$DATE"; then
6954   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
6955 $as_echo "$DATE" >&6; }
6956 else
6957   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6958 $as_echo "no" >&6; }
6959 fi
6960 
6961 
6962           if test "x$DATE" = x; then
6963             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6964           fi
6965         else
6966           # Otherwise we believe it is a complete path. Use it as it is.
6967           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DATE=$tool_specified" >&5
6968 $as_echo "$as_me: Will use user supplied tool DATE=$tool_specified" >&6;}
6969           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DATE" >&5
6970 $as_echo_n "checking for DATE... " >&6; }
6971           if test ! -x "$tool_specified"; then
6972             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6973 $as_echo "not found" >&6; }
6974             as_fn_error $? "User supplied tool DATE=$tool_specified does not exist or is not executable" "$LINENO" 5
6975           fi
6976           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6977 $as_echo "$tool_specified" >&6; }
6978         fi
6979       fi
6980     fi
6981 
6982   fi
6983 
6984 
6985 
6986   if test "x$DATE" = x; then
6987     as_fn_error $? "Could not find required tool for DATE" "$LINENO" 5
6988   fi
6989 
6990 
6991 
6992 
6993 
6994   # Publish this variable in the help.
6995 
6996 
6997   if [ -z "${DIFF+x}" ]; then
6998     # The variable is not set by user, try to locate tool using the code snippet
6999     for ac_prog in gdiff diff
7000 do
7001   # Extract the first word of "$ac_prog", so it can be a program name with args.
7002 set dummy $ac_prog; ac_word=$2
7003 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7004 $as_echo_n "checking for $ac_word... " >&6; }
7005 if ${ac_cv_path_DIFF+:} false; then :
7006   $as_echo_n "(cached) " >&6
7007 else
7008   case $DIFF in
7009   [\\/]* | ?:[\\/]*)
7010   ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
7011   ;;
7012   *)
7013   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7014 for as_dir in $PATH
7015 do
7016   IFS=$as_save_IFS
7017   test -z "$as_dir" && as_dir=.
7018     for ac_exec_ext in '' $ac_executable_extensions; do
7019   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7020     ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
7021     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7022     break 2
7023   fi
7024 done
7025   done
7026 IFS=$as_save_IFS
7027 
7028   ;;
7029 esac
7030 fi
7031 DIFF=$ac_cv_path_DIFF
7032 if test -n "$DIFF"; then
7033   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
7034 $as_echo "$DIFF" >&6; }
7035 else
7036   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7037 $as_echo "no" >&6; }
7038 fi
7039 
7040 
7041   test -n "$DIFF" && break
7042 done
7043 
7044   else
7045     # The variable is set, but is it from the command line or the environment?
7046 
7047     # Try to remove the string !DIFF! from our list.
7048     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DIFF!/}
7049     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7050       # If it failed, the variable was not from the command line. Ignore it,
7051       # but warn the user (except for BASH, which is always set by the calling BASH).
7052       if test "xDIFF" != xBASH; then
7053         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DIFF from the environment. Use command line variables instead." >&5
7054 $as_echo "$as_me: WARNING: Ignoring value of DIFF from the environment. Use command line variables instead." >&2;}
7055       fi
7056       # Try to locate tool using the code snippet
7057       for ac_prog in gdiff diff
7058 do
7059   # Extract the first word of "$ac_prog", so it can be a program name with args.
7060 set dummy $ac_prog; ac_word=$2
7061 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7062 $as_echo_n "checking for $ac_word... " >&6; }
7063 if ${ac_cv_path_DIFF+:} false; then :
7064   $as_echo_n "(cached) " >&6
7065 else
7066   case $DIFF in
7067   [\\/]* | ?:[\\/]*)
7068   ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
7069   ;;
7070   *)
7071   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7072 for as_dir in $PATH
7073 do
7074   IFS=$as_save_IFS
7075   test -z "$as_dir" && as_dir=.
7076     for ac_exec_ext in '' $ac_executable_extensions; do
7077   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7078     ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
7079     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7080     break 2
7081   fi
7082 done
7083   done
7084 IFS=$as_save_IFS
7085 
7086   ;;
7087 esac
7088 fi
7089 DIFF=$ac_cv_path_DIFF
7090 if test -n "$DIFF"; then
7091   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
7092 $as_echo "$DIFF" >&6; }
7093 else
7094   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7095 $as_echo "no" >&6; }
7096 fi
7097 
7098 
7099   test -n "$DIFF" && break
7100 done
7101 
7102     else
7103       # If it succeeded, then it was overridden by the user. We will use it
7104       # for the tool.
7105 
7106       # First remove it from the list of overridden variables, so we can test
7107       # for unknown variables in the end.
7108       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7109 
7110       # Check if we try to supply an empty value
7111       if test "x$DIFF" = x; then
7112         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool DIFF= (no value)" >&5
7113 $as_echo "$as_me: Setting user supplied tool DIFF= (no value)" >&6;}
7114         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIFF" >&5
7115 $as_echo_n "checking for DIFF... " >&6; }
7116         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
7117 $as_echo "disabled" >&6; }
7118       else
7119         # Check if the provided tool contains a complete path.
7120         tool_specified="$DIFF"
7121         tool_basename="${tool_specified##*/}"
7122         if test "x$tool_basename" = "x$tool_specified"; then
7123           # A command without a complete path is provided, search $PATH.
7124           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DIFF=$tool_basename" >&5
7125 $as_echo "$as_me: Will search for user supplied tool DIFF=$tool_basename" >&6;}
7126           # Extract the first word of "$tool_basename", so it can be a program name with args.
7127 set dummy $tool_basename; ac_word=$2
7128 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7129 $as_echo_n "checking for $ac_word... " >&6; }
7130 if ${ac_cv_path_DIFF+:} false; then :
7131   $as_echo_n "(cached) " >&6
7132 else
7133   case $DIFF in
7134   [\\/]* | ?:[\\/]*)
7135   ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
7136   ;;
7137   *)
7138   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7139 for as_dir in $PATH
7140 do
7141   IFS=$as_save_IFS
7142   test -z "$as_dir" && as_dir=.
7143     for ac_exec_ext in '' $ac_executable_extensions; do
7144   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7145     ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
7146     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7147     break 2
7148   fi
7149 done
7150   done
7151 IFS=$as_save_IFS
7152 
7153   ;;
7154 esac
7155 fi
7156 DIFF=$ac_cv_path_DIFF
7157 if test -n "$DIFF"; then
7158   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
7159 $as_echo "$DIFF" >&6; }
7160 else
7161   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7162 $as_echo "no" >&6; }
7163 fi
7164 
7165 
7166           if test "x$DIFF" = x; then
7167             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7168           fi
7169         else
7170           # Otherwise we believe it is a complete path. Use it as it is.
7171           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DIFF=$tool_specified" >&5
7172 $as_echo "$as_me: Will use user supplied tool DIFF=$tool_specified" >&6;}
7173           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIFF" >&5
7174 $as_echo_n "checking for DIFF... " >&6; }
7175           if test ! -x "$tool_specified"; then
7176             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7177 $as_echo "not found" >&6; }
7178             as_fn_error $? "User supplied tool DIFF=$tool_specified does not exist or is not executable" "$LINENO" 5
7179           fi
7180           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7181 $as_echo "$tool_specified" >&6; }
7182         fi
7183       fi
7184     fi
7185 
7186   fi
7187 
7188 
7189 
7190   if test "x$DIFF" = x; then
7191     as_fn_error $? "Could not find required tool for DIFF" "$LINENO" 5
7192   fi
7193 
7194 
7195 
7196 
7197 
7198   # Publish this variable in the help.
7199 
7200 
7201   if [ -z "${DIRNAME+x}" ]; then
7202     # The variable is not set by user, try to locate tool using the code snippet
7203     for ac_prog in dirname
7204 do
7205   # Extract the first word of "$ac_prog", so it can be a program name with args.
7206 set dummy $ac_prog; ac_word=$2
7207 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7208 $as_echo_n "checking for $ac_word... " >&6; }
7209 if ${ac_cv_path_DIRNAME+:} false; then :
7210   $as_echo_n "(cached) " >&6
7211 else
7212   case $DIRNAME in
7213   [\\/]* | ?:[\\/]*)
7214   ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
7215   ;;
7216   *)
7217   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7218 for as_dir in $PATH
7219 do
7220   IFS=$as_save_IFS
7221   test -z "$as_dir" && as_dir=.
7222     for ac_exec_ext in '' $ac_executable_extensions; do
7223   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7224     ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
7225     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7226     break 2
7227   fi
7228 done
7229   done
7230 IFS=$as_save_IFS
7231 
7232   ;;
7233 esac
7234 fi
7235 DIRNAME=$ac_cv_path_DIRNAME
7236 if test -n "$DIRNAME"; then
7237   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
7238 $as_echo "$DIRNAME" >&6; }
7239 else
7240   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7241 $as_echo "no" >&6; }
7242 fi
7243 
7244 
7245   test -n "$DIRNAME" && break
7246 done
7247 
7248   else
7249     # The variable is set, but is it from the command line or the environment?
7250 
7251     # Try to remove the string !DIRNAME! from our list.
7252     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DIRNAME!/}
7253     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7254       # If it failed, the variable was not from the command line. Ignore it,
7255       # but warn the user (except for BASH, which is always set by the calling BASH).
7256       if test "xDIRNAME" != xBASH; then
7257         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DIRNAME from the environment. Use command line variables instead." >&5
7258 $as_echo "$as_me: WARNING: Ignoring value of DIRNAME from the environment. Use command line variables instead." >&2;}
7259       fi
7260       # Try to locate tool using the code snippet
7261       for ac_prog in dirname
7262 do
7263   # Extract the first word of "$ac_prog", so it can be a program name with args.
7264 set dummy $ac_prog; ac_word=$2
7265 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7266 $as_echo_n "checking for $ac_word... " >&6; }
7267 if ${ac_cv_path_DIRNAME+:} false; then :
7268   $as_echo_n "(cached) " >&6
7269 else
7270   case $DIRNAME in
7271   [\\/]* | ?:[\\/]*)
7272   ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
7273   ;;
7274   *)
7275   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7276 for as_dir in $PATH
7277 do
7278   IFS=$as_save_IFS
7279   test -z "$as_dir" && as_dir=.
7280     for ac_exec_ext in '' $ac_executable_extensions; do
7281   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7282     ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
7283     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7284     break 2
7285   fi
7286 done
7287   done
7288 IFS=$as_save_IFS
7289 
7290   ;;
7291 esac
7292 fi
7293 DIRNAME=$ac_cv_path_DIRNAME
7294 if test -n "$DIRNAME"; then
7295   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
7296 $as_echo "$DIRNAME" >&6; }
7297 else
7298   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7299 $as_echo "no" >&6; }
7300 fi
7301 
7302 
7303   test -n "$DIRNAME" && break
7304 done
7305 
7306     else
7307       # If it succeeded, then it was overridden by the user. We will use it
7308       # for the tool.
7309 
7310       # First remove it from the list of overridden variables, so we can test
7311       # for unknown variables in the end.
7312       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7313 
7314       # Check if we try to supply an empty value
7315       if test "x$DIRNAME" = x; then
7316         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool DIRNAME= (no value)" >&5
7317 $as_echo "$as_me: Setting user supplied tool DIRNAME= (no value)" >&6;}
7318         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIRNAME" >&5
7319 $as_echo_n "checking for DIRNAME... " >&6; }
7320         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
7321 $as_echo "disabled" >&6; }
7322       else
7323         # Check if the provided tool contains a complete path.
7324         tool_specified="$DIRNAME"
7325         tool_basename="${tool_specified##*/}"
7326         if test "x$tool_basename" = "x$tool_specified"; then
7327           # A command without a complete path is provided, search $PATH.
7328           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DIRNAME=$tool_basename" >&5
7329 $as_echo "$as_me: Will search for user supplied tool DIRNAME=$tool_basename" >&6;}
7330           # Extract the first word of "$tool_basename", so it can be a program name with args.
7331 set dummy $tool_basename; ac_word=$2
7332 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7333 $as_echo_n "checking for $ac_word... " >&6; }
7334 if ${ac_cv_path_DIRNAME+:} false; then :
7335   $as_echo_n "(cached) " >&6
7336 else
7337   case $DIRNAME in
7338   [\\/]* | ?:[\\/]*)
7339   ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
7340   ;;
7341   *)
7342   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7343 for as_dir in $PATH
7344 do
7345   IFS=$as_save_IFS
7346   test -z "$as_dir" && as_dir=.
7347     for ac_exec_ext in '' $ac_executable_extensions; do
7348   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7349     ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
7350     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7351     break 2
7352   fi
7353 done
7354   done
7355 IFS=$as_save_IFS
7356 
7357   ;;
7358 esac
7359 fi
7360 DIRNAME=$ac_cv_path_DIRNAME
7361 if test -n "$DIRNAME"; then
7362   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
7363 $as_echo "$DIRNAME" >&6; }
7364 else
7365   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7366 $as_echo "no" >&6; }
7367 fi
7368 
7369 
7370           if test "x$DIRNAME" = x; then
7371             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7372           fi
7373         else
7374           # Otherwise we believe it is a complete path. Use it as it is.
7375           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DIRNAME=$tool_specified" >&5
7376 $as_echo "$as_me: Will use user supplied tool DIRNAME=$tool_specified" >&6;}
7377           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIRNAME" >&5
7378 $as_echo_n "checking for DIRNAME... " >&6; }
7379           if test ! -x "$tool_specified"; then
7380             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7381 $as_echo "not found" >&6; }
7382             as_fn_error $? "User supplied tool DIRNAME=$tool_specified does not exist or is not executable" "$LINENO" 5
7383           fi
7384           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7385 $as_echo "$tool_specified" >&6; }
7386         fi
7387       fi
7388     fi
7389 
7390   fi
7391 
7392 
7393 
7394   if test "x$DIRNAME" = x; then
7395     as_fn_error $? "Could not find required tool for DIRNAME" "$LINENO" 5
7396   fi
7397 
7398 
7399 
7400 
7401 
7402   # Publish this variable in the help.
7403 
7404 
7405   if [ -z "${ECHO+x}" ]; then
7406     # The variable is not set by user, try to locate tool using the code snippet
7407     for ac_prog in echo
7408 do
7409   # Extract the first word of "$ac_prog", so it can be a program name with args.
7410 set dummy $ac_prog; ac_word=$2
7411 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7412 $as_echo_n "checking for $ac_word... " >&6; }
7413 if ${ac_cv_path_ECHO+:} false; then :
7414   $as_echo_n "(cached) " >&6
7415 else
7416   case $ECHO in
7417   [\\/]* | ?:[\\/]*)
7418   ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
7419   ;;
7420   *)
7421   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7422 for as_dir in $PATH
7423 do
7424   IFS=$as_save_IFS
7425   test -z "$as_dir" && as_dir=.
7426     for ac_exec_ext in '' $ac_executable_extensions; do
7427   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7428     ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
7429     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7430     break 2
7431   fi
7432 done
7433   done
7434 IFS=$as_save_IFS
7435 
7436   ;;
7437 esac
7438 fi
7439 ECHO=$ac_cv_path_ECHO
7440 if test -n "$ECHO"; then
7441   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
7442 $as_echo "$ECHO" >&6; }
7443 else
7444   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7445 $as_echo "no" >&6; }
7446 fi
7447 
7448 
7449   test -n "$ECHO" && break
7450 done
7451 
7452   else
7453     # The variable is set, but is it from the command line or the environment?
7454 
7455     # Try to remove the string !ECHO! from our list.
7456     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!ECHO!/}
7457     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7458       # If it failed, the variable was not from the command line. Ignore it,
7459       # but warn the user (except for BASH, which is always set by the calling BASH).
7460       if test "xECHO" != xBASH; then
7461         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ECHO from the environment. Use command line variables instead." >&5
7462 $as_echo "$as_me: WARNING: Ignoring value of ECHO from the environment. Use command line variables instead." >&2;}
7463       fi
7464       # Try to locate tool using the code snippet
7465       for ac_prog in echo
7466 do
7467   # Extract the first word of "$ac_prog", so it can be a program name with args.
7468 set dummy $ac_prog; ac_word=$2
7469 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7470 $as_echo_n "checking for $ac_word... " >&6; }
7471 if ${ac_cv_path_ECHO+:} false; then :
7472   $as_echo_n "(cached) " >&6
7473 else
7474   case $ECHO in
7475   [\\/]* | ?:[\\/]*)
7476   ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
7477   ;;
7478   *)
7479   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7480 for as_dir in $PATH
7481 do
7482   IFS=$as_save_IFS
7483   test -z "$as_dir" && as_dir=.
7484     for ac_exec_ext in '' $ac_executable_extensions; do
7485   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7486     ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
7487     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7488     break 2
7489   fi
7490 done
7491   done
7492 IFS=$as_save_IFS
7493 
7494   ;;
7495 esac
7496 fi
7497 ECHO=$ac_cv_path_ECHO
7498 if test -n "$ECHO"; then
7499   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
7500 $as_echo "$ECHO" >&6; }
7501 else
7502   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7503 $as_echo "no" >&6; }
7504 fi
7505 
7506 
7507   test -n "$ECHO" && break
7508 done
7509 
7510     else
7511       # If it succeeded, then it was overridden by the user. We will use it
7512       # for the tool.
7513 
7514       # First remove it from the list of overridden variables, so we can test
7515       # for unknown variables in the end.
7516       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7517 
7518       # Check if we try to supply an empty value
7519       if test "x$ECHO" = x; then
7520         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool ECHO= (no value)" >&5
7521 $as_echo "$as_me: Setting user supplied tool ECHO= (no value)" >&6;}
7522         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ECHO" >&5
7523 $as_echo_n "checking for ECHO... " >&6; }
7524         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
7525 $as_echo "disabled" >&6; }
7526       else
7527         # Check if the provided tool contains a complete path.
7528         tool_specified="$ECHO"
7529         tool_basename="${tool_specified##*/}"
7530         if test "x$tool_basename" = "x$tool_specified"; then
7531           # A command without a complete path is provided, search $PATH.
7532           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ECHO=$tool_basename" >&5
7533 $as_echo "$as_me: Will search for user supplied tool ECHO=$tool_basename" >&6;}
7534           # Extract the first word of "$tool_basename", so it can be a program name with args.
7535 set dummy $tool_basename; ac_word=$2
7536 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7537 $as_echo_n "checking for $ac_word... " >&6; }
7538 if ${ac_cv_path_ECHO+:} false; then :
7539   $as_echo_n "(cached) " >&6
7540 else
7541   case $ECHO in
7542   [\\/]* | ?:[\\/]*)
7543   ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
7544   ;;
7545   *)
7546   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7547 for as_dir in $PATH
7548 do
7549   IFS=$as_save_IFS
7550   test -z "$as_dir" && as_dir=.
7551     for ac_exec_ext in '' $ac_executable_extensions; do
7552   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7553     ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
7554     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7555     break 2
7556   fi
7557 done
7558   done
7559 IFS=$as_save_IFS
7560 
7561   ;;
7562 esac
7563 fi
7564 ECHO=$ac_cv_path_ECHO
7565 if test -n "$ECHO"; then
7566   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
7567 $as_echo "$ECHO" >&6; }
7568 else
7569   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7570 $as_echo "no" >&6; }
7571 fi
7572 
7573 
7574           if test "x$ECHO" = x; then
7575             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7576           fi
7577         else
7578           # Otherwise we believe it is a complete path. Use it as it is.
7579           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ECHO=$tool_specified" >&5
7580 $as_echo "$as_me: Will use user supplied tool ECHO=$tool_specified" >&6;}
7581           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ECHO" >&5
7582 $as_echo_n "checking for ECHO... " >&6; }
7583           if test ! -x "$tool_specified"; then
7584             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7585 $as_echo "not found" >&6; }
7586             as_fn_error $? "User supplied tool ECHO=$tool_specified does not exist or is not executable" "$LINENO" 5
7587           fi
7588           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7589 $as_echo "$tool_specified" >&6; }
7590         fi
7591       fi
7592     fi
7593 
7594   fi
7595 
7596 
7597 
7598   if test "x$ECHO" = x; then
7599     as_fn_error $? "Could not find required tool for ECHO" "$LINENO" 5
7600   fi
7601 
7602 
7603 
7604 
7605 
7606   # Publish this variable in the help.
7607 
7608 
7609   if [ -z "${EXPR+x}" ]; then
7610     # The variable is not set by user, try to locate tool using the code snippet
7611     for ac_prog in expr
7612 do
7613   # Extract the first word of "$ac_prog", so it can be a program name with args.
7614 set dummy $ac_prog; ac_word=$2
7615 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7616 $as_echo_n "checking for $ac_word... " >&6; }
7617 if ${ac_cv_path_EXPR+:} false; then :
7618   $as_echo_n "(cached) " >&6
7619 else
7620   case $EXPR in
7621   [\\/]* | ?:[\\/]*)
7622   ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
7623   ;;
7624   *)
7625   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7626 for as_dir in $PATH
7627 do
7628   IFS=$as_save_IFS
7629   test -z "$as_dir" && as_dir=.
7630     for ac_exec_ext in '' $ac_executable_extensions; do
7631   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7632     ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
7633     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7634     break 2
7635   fi
7636 done
7637   done
7638 IFS=$as_save_IFS
7639 
7640   ;;
7641 esac
7642 fi
7643 EXPR=$ac_cv_path_EXPR
7644 if test -n "$EXPR"; then
7645   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
7646 $as_echo "$EXPR" >&6; }
7647 else
7648   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7649 $as_echo "no" >&6; }
7650 fi
7651 
7652 
7653   test -n "$EXPR" && break
7654 done
7655 
7656   else
7657     # The variable is set, but is it from the command line or the environment?
7658 
7659     # Try to remove the string !EXPR! from our list.
7660     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!EXPR!/}
7661     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7662       # If it failed, the variable was not from the command line. Ignore it,
7663       # but warn the user (except for BASH, which is always set by the calling BASH).
7664       if test "xEXPR" != xBASH; then
7665         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of EXPR from the environment. Use command line variables instead." >&5
7666 $as_echo "$as_me: WARNING: Ignoring value of EXPR from the environment. Use command line variables instead." >&2;}
7667       fi
7668       # Try to locate tool using the code snippet
7669       for ac_prog in expr
7670 do
7671   # Extract the first word of "$ac_prog", so it can be a program name with args.
7672 set dummy $ac_prog; ac_word=$2
7673 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7674 $as_echo_n "checking for $ac_word... " >&6; }
7675 if ${ac_cv_path_EXPR+:} false; then :
7676   $as_echo_n "(cached) " >&6
7677 else
7678   case $EXPR in
7679   [\\/]* | ?:[\\/]*)
7680   ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
7681   ;;
7682   *)
7683   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7684 for as_dir in $PATH
7685 do
7686   IFS=$as_save_IFS
7687   test -z "$as_dir" && as_dir=.
7688     for ac_exec_ext in '' $ac_executable_extensions; do
7689   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7690     ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
7691     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7692     break 2
7693   fi
7694 done
7695   done
7696 IFS=$as_save_IFS
7697 
7698   ;;
7699 esac
7700 fi
7701 EXPR=$ac_cv_path_EXPR
7702 if test -n "$EXPR"; then
7703   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
7704 $as_echo "$EXPR" >&6; }
7705 else
7706   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7707 $as_echo "no" >&6; }
7708 fi
7709 
7710 
7711   test -n "$EXPR" && break
7712 done
7713 
7714     else
7715       # If it succeeded, then it was overridden by the user. We will use it
7716       # for the tool.
7717 
7718       # First remove it from the list of overridden variables, so we can test
7719       # for unknown variables in the end.
7720       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7721 
7722       # Check if we try to supply an empty value
7723       if test "x$EXPR" = x; then
7724         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool EXPR= (no value)" >&5
7725 $as_echo "$as_me: Setting user supplied tool EXPR= (no value)" >&6;}
7726         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EXPR" >&5
7727 $as_echo_n "checking for EXPR... " >&6; }
7728         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
7729 $as_echo "disabled" >&6; }
7730       else
7731         # Check if the provided tool contains a complete path.
7732         tool_specified="$EXPR"
7733         tool_basename="${tool_specified##*/}"
7734         if test "x$tool_basename" = "x$tool_specified"; then
7735           # A command without a complete path is provided, search $PATH.
7736           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool EXPR=$tool_basename" >&5
7737 $as_echo "$as_me: Will search for user supplied tool EXPR=$tool_basename" >&6;}
7738           # Extract the first word of "$tool_basename", so it can be a program name with args.
7739 set dummy $tool_basename; ac_word=$2
7740 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7741 $as_echo_n "checking for $ac_word... " >&6; }
7742 if ${ac_cv_path_EXPR+:} false; then :
7743   $as_echo_n "(cached) " >&6
7744 else
7745   case $EXPR in
7746   [\\/]* | ?:[\\/]*)
7747   ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
7748   ;;
7749   *)
7750   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7751 for as_dir in $PATH
7752 do
7753   IFS=$as_save_IFS
7754   test -z "$as_dir" && as_dir=.
7755     for ac_exec_ext in '' $ac_executable_extensions; do
7756   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7757     ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
7758     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7759     break 2
7760   fi
7761 done
7762   done
7763 IFS=$as_save_IFS
7764 
7765   ;;
7766 esac
7767 fi
7768 EXPR=$ac_cv_path_EXPR
7769 if test -n "$EXPR"; then
7770   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
7771 $as_echo "$EXPR" >&6; }
7772 else
7773   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7774 $as_echo "no" >&6; }
7775 fi
7776 
7777 
7778           if test "x$EXPR" = x; then
7779             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7780           fi
7781         else
7782           # Otherwise we believe it is a complete path. Use it as it is.
7783           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool EXPR=$tool_specified" >&5
7784 $as_echo "$as_me: Will use user supplied tool EXPR=$tool_specified" >&6;}
7785           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EXPR" >&5
7786 $as_echo_n "checking for EXPR... " >&6; }
7787           if test ! -x "$tool_specified"; then
7788             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7789 $as_echo "not found" >&6; }
7790             as_fn_error $? "User supplied tool EXPR=$tool_specified does not exist or is not executable" "$LINENO" 5
7791           fi
7792           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7793 $as_echo "$tool_specified" >&6; }
7794         fi
7795       fi
7796     fi
7797 
7798   fi
7799 
7800 
7801 
7802   if test "x$EXPR" = x; then
7803     as_fn_error $? "Could not find required tool for EXPR" "$LINENO" 5
7804   fi
7805 
7806 
7807 
7808 
7809 
7810   # Publish this variable in the help.
7811 
7812 
7813   if [ -z "${FILE+x}" ]; then
7814     # The variable is not set by user, try to locate tool using the code snippet
7815     for ac_prog in file
7816 do
7817   # Extract the first word of "$ac_prog", so it can be a program name with args.
7818 set dummy $ac_prog; ac_word=$2
7819 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7820 $as_echo_n "checking for $ac_word... " >&6; }
7821 if ${ac_cv_path_FILE+:} false; then :
7822   $as_echo_n "(cached) " >&6
7823 else
7824   case $FILE in
7825   [\\/]* | ?:[\\/]*)
7826   ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
7827   ;;
7828   *)
7829   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7830 for as_dir in $PATH
7831 do
7832   IFS=$as_save_IFS
7833   test -z "$as_dir" && as_dir=.
7834     for ac_exec_ext in '' $ac_executable_extensions; do
7835   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7836     ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
7837     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7838     break 2
7839   fi
7840 done
7841   done
7842 IFS=$as_save_IFS
7843 
7844   ;;
7845 esac
7846 fi
7847 FILE=$ac_cv_path_FILE
7848 if test -n "$FILE"; then
7849   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
7850 $as_echo "$FILE" >&6; }
7851 else
7852   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7853 $as_echo "no" >&6; }
7854 fi
7855 
7856 
7857   test -n "$FILE" && break
7858 done
7859 
7860   else
7861     # The variable is set, but is it from the command line or the environment?
7862 
7863     # Try to remove the string !FILE! from our list.
7864     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FILE!/}
7865     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7866       # If it failed, the variable was not from the command line. Ignore it,
7867       # but warn the user (except for BASH, which is always set by the calling BASH).
7868       if test "xFILE" != xBASH; then
7869         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FILE from the environment. Use command line variables instead." >&5
7870 $as_echo "$as_me: WARNING: Ignoring value of FILE from the environment. Use command line variables instead." >&2;}
7871       fi
7872       # Try to locate tool using the code snippet
7873       for ac_prog in file
7874 do
7875   # Extract the first word of "$ac_prog", so it can be a program name with args.
7876 set dummy $ac_prog; ac_word=$2
7877 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7878 $as_echo_n "checking for $ac_word... " >&6; }
7879 if ${ac_cv_path_FILE+:} false; then :
7880   $as_echo_n "(cached) " >&6
7881 else
7882   case $FILE in
7883   [\\/]* | ?:[\\/]*)
7884   ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
7885   ;;
7886   *)
7887   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7888 for as_dir in $PATH
7889 do
7890   IFS=$as_save_IFS
7891   test -z "$as_dir" && as_dir=.
7892     for ac_exec_ext in '' $ac_executable_extensions; do
7893   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7894     ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
7895     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7896     break 2
7897   fi
7898 done
7899   done
7900 IFS=$as_save_IFS
7901 
7902   ;;
7903 esac
7904 fi
7905 FILE=$ac_cv_path_FILE
7906 if test -n "$FILE"; then
7907   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
7908 $as_echo "$FILE" >&6; }
7909 else
7910   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7911 $as_echo "no" >&6; }
7912 fi
7913 
7914 
7915   test -n "$FILE" && break
7916 done
7917 
7918     else
7919       # If it succeeded, then it was overridden by the user. We will use it
7920       # for the tool.
7921 
7922       # First remove it from the list of overridden variables, so we can test
7923       # for unknown variables in the end.
7924       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7925 
7926       # Check if we try to supply an empty value
7927       if test "x$FILE" = x; then
7928         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool FILE= (no value)" >&5
7929 $as_echo "$as_me: Setting user supplied tool FILE= (no value)" >&6;}
7930         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FILE" >&5
7931 $as_echo_n "checking for FILE... " >&6; }
7932         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
7933 $as_echo "disabled" >&6; }
7934       else
7935         # Check if the provided tool contains a complete path.
7936         tool_specified="$FILE"
7937         tool_basename="${tool_specified##*/}"
7938         if test "x$tool_basename" = "x$tool_specified"; then
7939           # A command without a complete path is provided, search $PATH.
7940           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FILE=$tool_basename" >&5
7941 $as_echo "$as_me: Will search for user supplied tool FILE=$tool_basename" >&6;}
7942           # Extract the first word of "$tool_basename", so it can be a program name with args.
7943 set dummy $tool_basename; ac_word=$2
7944 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7945 $as_echo_n "checking for $ac_word... " >&6; }
7946 if ${ac_cv_path_FILE+:} false; then :
7947   $as_echo_n "(cached) " >&6
7948 else
7949   case $FILE in
7950   [\\/]* | ?:[\\/]*)
7951   ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
7952   ;;
7953   *)
7954   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7955 for as_dir in $PATH
7956 do
7957   IFS=$as_save_IFS
7958   test -z "$as_dir" && as_dir=.
7959     for ac_exec_ext in '' $ac_executable_extensions; do
7960   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7961     ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
7962     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7963     break 2
7964   fi
7965 done
7966   done
7967 IFS=$as_save_IFS
7968 
7969   ;;
7970 esac
7971 fi
7972 FILE=$ac_cv_path_FILE
7973 if test -n "$FILE"; then
7974   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
7975 $as_echo "$FILE" >&6; }
7976 else
7977   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7978 $as_echo "no" >&6; }
7979 fi
7980 
7981 
7982           if test "x$FILE" = x; then
7983             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7984           fi
7985         else
7986           # Otherwise we believe it is a complete path. Use it as it is.
7987           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FILE=$tool_specified" >&5
7988 $as_echo "$as_me: Will use user supplied tool FILE=$tool_specified" >&6;}
7989           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FILE" >&5
7990 $as_echo_n "checking for FILE... " >&6; }
7991           if test ! -x "$tool_specified"; then
7992             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7993 $as_echo "not found" >&6; }
7994             as_fn_error $? "User supplied tool FILE=$tool_specified does not exist or is not executable" "$LINENO" 5
7995           fi
7996           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7997 $as_echo "$tool_specified" >&6; }
7998         fi
7999       fi
8000     fi
8001 
8002   fi
8003 
8004 
8005 
8006   if test "x$FILE" = x; then
8007     as_fn_error $? "Could not find required tool for FILE" "$LINENO" 5
8008   fi
8009 
8010 
8011 
8012 
8013 
8014   # Publish this variable in the help.
8015 
8016 
8017   if [ -z "${FIND+x}" ]; then
8018     # The variable is not set by user, try to locate tool using the code snippet
8019     for ac_prog in find
8020 do
8021   # Extract the first word of "$ac_prog", so it can be a program name with args.
8022 set dummy $ac_prog; ac_word=$2
8023 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8024 $as_echo_n "checking for $ac_word... " >&6; }
8025 if ${ac_cv_path_FIND+:} false; then :
8026   $as_echo_n "(cached) " >&6
8027 else
8028   case $FIND in
8029   [\\/]* | ?:[\\/]*)
8030   ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
8031   ;;
8032   *)
8033   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8034 for as_dir in $PATH
8035 do
8036   IFS=$as_save_IFS
8037   test -z "$as_dir" && as_dir=.
8038     for ac_exec_ext in '' $ac_executable_extensions; do
8039   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8040     ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
8041     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8042     break 2
8043   fi
8044 done
8045   done
8046 IFS=$as_save_IFS
8047 
8048   ;;
8049 esac
8050 fi
8051 FIND=$ac_cv_path_FIND
8052 if test -n "$FIND"; then
8053   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
8054 $as_echo "$FIND" >&6; }
8055 else
8056   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8057 $as_echo "no" >&6; }
8058 fi
8059 
8060 
8061   test -n "$FIND" && break
8062 done
8063 
8064   else
8065     # The variable is set, but is it from the command line or the environment?
8066 
8067     # Try to remove the string !FIND! from our list.
8068     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FIND!/}
8069     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8070       # If it failed, the variable was not from the command line. Ignore it,
8071       # but warn the user (except for BASH, which is always set by the calling BASH).
8072       if test "xFIND" != xBASH; then
8073         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FIND from the environment. Use command line variables instead." >&5
8074 $as_echo "$as_me: WARNING: Ignoring value of FIND from the environment. Use command line variables instead." >&2;}
8075       fi
8076       # Try to locate tool using the code snippet
8077       for ac_prog in find
8078 do
8079   # Extract the first word of "$ac_prog", so it can be a program name with args.
8080 set dummy $ac_prog; ac_word=$2
8081 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8082 $as_echo_n "checking for $ac_word... " >&6; }
8083 if ${ac_cv_path_FIND+:} false; then :
8084   $as_echo_n "(cached) " >&6
8085 else
8086   case $FIND in
8087   [\\/]* | ?:[\\/]*)
8088   ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
8089   ;;
8090   *)
8091   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8092 for as_dir in $PATH
8093 do
8094   IFS=$as_save_IFS
8095   test -z "$as_dir" && as_dir=.
8096     for ac_exec_ext in '' $ac_executable_extensions; do
8097   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8098     ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
8099     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8100     break 2
8101   fi
8102 done
8103   done
8104 IFS=$as_save_IFS
8105 
8106   ;;
8107 esac
8108 fi
8109 FIND=$ac_cv_path_FIND
8110 if test -n "$FIND"; then
8111   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
8112 $as_echo "$FIND" >&6; }
8113 else
8114   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8115 $as_echo "no" >&6; }
8116 fi
8117 
8118 
8119   test -n "$FIND" && break
8120 done
8121 
8122     else
8123       # If it succeeded, then it was overridden by the user. We will use it
8124       # for the tool.
8125 
8126       # First remove it from the list of overridden variables, so we can test
8127       # for unknown variables in the end.
8128       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8129 
8130       # Check if we try to supply an empty value
8131       if test "x$FIND" = x; then
8132         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool FIND= (no value)" >&5
8133 $as_echo "$as_me: Setting user supplied tool FIND= (no value)" >&6;}
8134         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FIND" >&5
8135 $as_echo_n "checking for FIND... " >&6; }
8136         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
8137 $as_echo "disabled" >&6; }
8138       else
8139         # Check if the provided tool contains a complete path.
8140         tool_specified="$FIND"
8141         tool_basename="${tool_specified##*/}"
8142         if test "x$tool_basename" = "x$tool_specified"; then
8143           # A command without a complete path is provided, search $PATH.
8144           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FIND=$tool_basename" >&5
8145 $as_echo "$as_me: Will search for user supplied tool FIND=$tool_basename" >&6;}
8146           # Extract the first word of "$tool_basename", so it can be a program name with args.
8147 set dummy $tool_basename; ac_word=$2
8148 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8149 $as_echo_n "checking for $ac_word... " >&6; }
8150 if ${ac_cv_path_FIND+:} false; then :
8151   $as_echo_n "(cached) " >&6
8152 else
8153   case $FIND in
8154   [\\/]* | ?:[\\/]*)
8155   ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
8156   ;;
8157   *)
8158   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8159 for as_dir in $PATH
8160 do
8161   IFS=$as_save_IFS
8162   test -z "$as_dir" && as_dir=.
8163     for ac_exec_ext in '' $ac_executable_extensions; do
8164   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8165     ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
8166     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8167     break 2
8168   fi
8169 done
8170   done
8171 IFS=$as_save_IFS
8172 
8173   ;;
8174 esac
8175 fi
8176 FIND=$ac_cv_path_FIND
8177 if test -n "$FIND"; then
8178   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
8179 $as_echo "$FIND" >&6; }
8180 else
8181   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8182 $as_echo "no" >&6; }
8183 fi
8184 
8185 
8186           if test "x$FIND" = x; then
8187             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8188           fi
8189         else
8190           # Otherwise we believe it is a complete path. Use it as it is.
8191           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FIND=$tool_specified" >&5
8192 $as_echo "$as_me: Will use user supplied tool FIND=$tool_specified" >&6;}
8193           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FIND" >&5
8194 $as_echo_n "checking for FIND... " >&6; }
8195           if test ! -x "$tool_specified"; then
8196             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8197 $as_echo "not found" >&6; }
8198             as_fn_error $? "User supplied tool FIND=$tool_specified does not exist or is not executable" "$LINENO" 5
8199           fi
8200           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8201 $as_echo "$tool_specified" >&6; }
8202         fi
8203       fi
8204     fi
8205 
8206   fi
8207 
8208 
8209 
8210   if test "x$FIND" = x; then
8211     as_fn_error $? "Could not find required tool for FIND" "$LINENO" 5
8212   fi
8213 
8214 
8215 
8216 
8217 
8218   # Publish this variable in the help.
8219 
8220 
8221   if [ -z "${HEAD+x}" ]; then
8222     # The variable is not set by user, try to locate tool using the code snippet
8223     for ac_prog in head
8224 do
8225   # Extract the first word of "$ac_prog", so it can be a program name with args.
8226 set dummy $ac_prog; ac_word=$2
8227 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8228 $as_echo_n "checking for $ac_word... " >&6; }
8229 if ${ac_cv_path_HEAD+:} false; then :
8230   $as_echo_n "(cached) " >&6
8231 else
8232   case $HEAD in
8233   [\\/]* | ?:[\\/]*)
8234   ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
8235   ;;
8236   *)
8237   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8238 for as_dir in $PATH
8239 do
8240   IFS=$as_save_IFS
8241   test -z "$as_dir" && as_dir=.
8242     for ac_exec_ext in '' $ac_executable_extensions; do
8243   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8244     ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
8245     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8246     break 2
8247   fi
8248 done
8249   done
8250 IFS=$as_save_IFS
8251 
8252   ;;
8253 esac
8254 fi
8255 HEAD=$ac_cv_path_HEAD
8256 if test -n "$HEAD"; then
8257   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
8258 $as_echo "$HEAD" >&6; }
8259 else
8260   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8261 $as_echo "no" >&6; }
8262 fi
8263 
8264 
8265   test -n "$HEAD" && break
8266 done
8267 
8268   else
8269     # The variable is set, but is it from the command line or the environment?
8270 
8271     # Try to remove the string !HEAD! from our list.
8272     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!HEAD!/}
8273     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8274       # If it failed, the variable was not from the command line. Ignore it,
8275       # but warn the user (except for BASH, which is always set by the calling BASH).
8276       if test "xHEAD" != xBASH; then
8277         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of HEAD from the environment. Use command line variables instead." >&5
8278 $as_echo "$as_me: WARNING: Ignoring value of HEAD from the environment. Use command line variables instead." >&2;}
8279       fi
8280       # Try to locate tool using the code snippet
8281       for ac_prog in head
8282 do
8283   # Extract the first word of "$ac_prog", so it can be a program name with args.
8284 set dummy $ac_prog; ac_word=$2
8285 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8286 $as_echo_n "checking for $ac_word... " >&6; }
8287 if ${ac_cv_path_HEAD+:} false; then :
8288   $as_echo_n "(cached) " >&6
8289 else
8290   case $HEAD in
8291   [\\/]* | ?:[\\/]*)
8292   ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
8293   ;;
8294   *)
8295   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8296 for as_dir in $PATH
8297 do
8298   IFS=$as_save_IFS
8299   test -z "$as_dir" && as_dir=.
8300     for ac_exec_ext in '' $ac_executable_extensions; do
8301   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8302     ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
8303     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8304     break 2
8305   fi
8306 done
8307   done
8308 IFS=$as_save_IFS
8309 
8310   ;;
8311 esac
8312 fi
8313 HEAD=$ac_cv_path_HEAD
8314 if test -n "$HEAD"; then
8315   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
8316 $as_echo "$HEAD" >&6; }
8317 else
8318   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8319 $as_echo "no" >&6; }
8320 fi
8321 
8322 
8323   test -n "$HEAD" && break
8324 done
8325 
8326     else
8327       # If it succeeded, then it was overridden by the user. We will use it
8328       # for the tool.
8329 
8330       # First remove it from the list of overridden variables, so we can test
8331       # for unknown variables in the end.
8332       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8333 
8334       # Check if we try to supply an empty value
8335       if test "x$HEAD" = x; then
8336         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool HEAD= (no value)" >&5
8337 $as_echo "$as_me: Setting user supplied tool HEAD= (no value)" >&6;}
8338         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HEAD" >&5
8339 $as_echo_n "checking for HEAD... " >&6; }
8340         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
8341 $as_echo "disabled" >&6; }
8342       else
8343         # Check if the provided tool contains a complete path.
8344         tool_specified="$HEAD"
8345         tool_basename="${tool_specified##*/}"
8346         if test "x$tool_basename" = "x$tool_specified"; then
8347           # A command without a complete path is provided, search $PATH.
8348           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool HEAD=$tool_basename" >&5
8349 $as_echo "$as_me: Will search for user supplied tool HEAD=$tool_basename" >&6;}
8350           # Extract the first word of "$tool_basename", so it can be a program name with args.
8351 set dummy $tool_basename; ac_word=$2
8352 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8353 $as_echo_n "checking for $ac_word... " >&6; }
8354 if ${ac_cv_path_HEAD+:} false; then :
8355   $as_echo_n "(cached) " >&6
8356 else
8357   case $HEAD in
8358   [\\/]* | ?:[\\/]*)
8359   ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
8360   ;;
8361   *)
8362   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8363 for as_dir in $PATH
8364 do
8365   IFS=$as_save_IFS
8366   test -z "$as_dir" && as_dir=.
8367     for ac_exec_ext in '' $ac_executable_extensions; do
8368   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8369     ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
8370     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8371     break 2
8372   fi
8373 done
8374   done
8375 IFS=$as_save_IFS
8376 
8377   ;;
8378 esac
8379 fi
8380 HEAD=$ac_cv_path_HEAD
8381 if test -n "$HEAD"; then
8382   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
8383 $as_echo "$HEAD" >&6; }
8384 else
8385   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8386 $as_echo "no" >&6; }
8387 fi
8388 
8389 
8390           if test "x$HEAD" = x; then
8391             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8392           fi
8393         else
8394           # Otherwise we believe it is a complete path. Use it as it is.
8395           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool HEAD=$tool_specified" >&5
8396 $as_echo "$as_me: Will use user supplied tool HEAD=$tool_specified" >&6;}
8397           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HEAD" >&5
8398 $as_echo_n "checking for HEAD... " >&6; }
8399           if test ! -x "$tool_specified"; then
8400             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8401 $as_echo "not found" >&6; }
8402             as_fn_error $? "User supplied tool HEAD=$tool_specified does not exist or is not executable" "$LINENO" 5
8403           fi
8404           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8405 $as_echo "$tool_specified" >&6; }
8406         fi
8407       fi
8408     fi
8409 
8410   fi
8411 
8412 
8413 
8414   if test "x$HEAD" = x; then
8415     as_fn_error $? "Could not find required tool for HEAD" "$LINENO" 5
8416   fi
8417 
8418 
8419 
8420 
8421 
8422   # Publish this variable in the help.
8423 
8424 
8425   if [ -z "${GUNZIP+x}" ]; then
8426     # The variable is not set by user, try to locate tool using the code snippet
8427     for ac_prog in gunzip
8428 do
8429   # Extract the first word of "$ac_prog", so it can be a program name with args.
8430 set dummy $ac_prog; ac_word=$2
8431 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8432 $as_echo_n "checking for $ac_word... " >&6; }
8433 if ${ac_cv_path_GUNZIP+:} false; then :
8434   $as_echo_n "(cached) " >&6
8435 else
8436   case $GUNZIP in
8437   [\\/]* | ?:[\\/]*)
8438   ac_cv_path_GUNZIP="$GUNZIP" # Let the user override the test with a path.
8439   ;;
8440   *)
8441   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8442 for as_dir in $PATH
8443 do
8444   IFS=$as_save_IFS
8445   test -z "$as_dir" && as_dir=.
8446     for ac_exec_ext in '' $ac_executable_extensions; do
8447   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8448     ac_cv_path_GUNZIP="$as_dir/$ac_word$ac_exec_ext"
8449     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8450     break 2
8451   fi
8452 done
8453   done
8454 IFS=$as_save_IFS
8455 
8456   ;;
8457 esac
8458 fi
8459 GUNZIP=$ac_cv_path_GUNZIP
8460 if test -n "$GUNZIP"; then
8461   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GUNZIP" >&5
8462 $as_echo "$GUNZIP" >&6; }
8463 else
8464   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8465 $as_echo "no" >&6; }
8466 fi
8467 
8468 
8469   test -n "$GUNZIP" && break
8470 done
8471 
8472   else
8473     # The variable is set, but is it from the command line or the environment?
8474 
8475     # Try to remove the string !GUNZIP! from our list.
8476     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!GUNZIP!/}
8477     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8478       # If it failed, the variable was not from the command line. Ignore it,
8479       # but warn the user (except for BASH, which is always set by the calling BASH).
8480       if test "xGUNZIP" != xBASH; then
8481         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of GUNZIP from the environment. Use command line variables instead." >&5
8482 $as_echo "$as_me: WARNING: Ignoring value of GUNZIP from the environment. Use command line variables instead." >&2;}
8483       fi
8484       # Try to locate tool using the code snippet
8485       for ac_prog in gunzip
8486 do
8487   # Extract the first word of "$ac_prog", so it can be a program name with args.
8488 set dummy $ac_prog; ac_word=$2
8489 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8490 $as_echo_n "checking for $ac_word... " >&6; }
8491 if ${ac_cv_path_GUNZIP+:} false; then :
8492   $as_echo_n "(cached) " >&6
8493 else
8494   case $GUNZIP in
8495   [\\/]* | ?:[\\/]*)
8496   ac_cv_path_GUNZIP="$GUNZIP" # Let the user override the test with a path.
8497   ;;
8498   *)
8499   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8500 for as_dir in $PATH
8501 do
8502   IFS=$as_save_IFS
8503   test -z "$as_dir" && as_dir=.
8504     for ac_exec_ext in '' $ac_executable_extensions; do
8505   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8506     ac_cv_path_GUNZIP="$as_dir/$ac_word$ac_exec_ext"
8507     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8508     break 2
8509   fi
8510 done
8511   done
8512 IFS=$as_save_IFS
8513 
8514   ;;
8515 esac
8516 fi
8517 GUNZIP=$ac_cv_path_GUNZIP
8518 if test -n "$GUNZIP"; then
8519   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GUNZIP" >&5
8520 $as_echo "$GUNZIP" >&6; }
8521 else
8522   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8523 $as_echo "no" >&6; }
8524 fi
8525 
8526 
8527   test -n "$GUNZIP" && break
8528 done
8529 
8530     else
8531       # If it succeeded, then it was overridden by the user. We will use it
8532       # for the tool.
8533 
8534       # First remove it from the list of overridden variables, so we can test
8535       # for unknown variables in the end.
8536       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8537 
8538       # Check if we try to supply an empty value
8539       if test "x$GUNZIP" = x; then
8540         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool GUNZIP= (no value)" >&5
8541 $as_echo "$as_me: Setting user supplied tool GUNZIP= (no value)" >&6;}
8542         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GUNZIP" >&5
8543 $as_echo_n "checking for GUNZIP... " >&6; }
8544         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
8545 $as_echo "disabled" >&6; }
8546       else
8547         # Check if the provided tool contains a complete path.
8548         tool_specified="$GUNZIP"
8549         tool_basename="${tool_specified##*/}"
8550         if test "x$tool_basename" = "x$tool_specified"; then
8551           # A command without a complete path is provided, search $PATH.
8552           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool GUNZIP=$tool_basename" >&5
8553 $as_echo "$as_me: Will search for user supplied tool GUNZIP=$tool_basename" >&6;}
8554           # Extract the first word of "$tool_basename", so it can be a program name with args.
8555 set dummy $tool_basename; ac_word=$2
8556 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8557 $as_echo_n "checking for $ac_word... " >&6; }
8558 if ${ac_cv_path_GUNZIP+:} false; then :
8559   $as_echo_n "(cached) " >&6
8560 else
8561   case $GUNZIP in
8562   [\\/]* | ?:[\\/]*)
8563   ac_cv_path_GUNZIP="$GUNZIP" # Let the user override the test with a path.
8564   ;;
8565   *)
8566   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8567 for as_dir in $PATH
8568 do
8569   IFS=$as_save_IFS
8570   test -z "$as_dir" && as_dir=.
8571     for ac_exec_ext in '' $ac_executable_extensions; do
8572   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8573     ac_cv_path_GUNZIP="$as_dir/$ac_word$ac_exec_ext"
8574     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8575     break 2
8576   fi
8577 done
8578   done
8579 IFS=$as_save_IFS
8580 
8581   ;;
8582 esac
8583 fi
8584 GUNZIP=$ac_cv_path_GUNZIP
8585 if test -n "$GUNZIP"; then
8586   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GUNZIP" >&5
8587 $as_echo "$GUNZIP" >&6; }
8588 else
8589   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8590 $as_echo "no" >&6; }
8591 fi
8592 
8593 
8594           if test "x$GUNZIP" = x; then
8595             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8596           fi
8597         else
8598           # Otherwise we believe it is a complete path. Use it as it is.
8599           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool GUNZIP=$tool_specified" >&5
8600 $as_echo "$as_me: Will use user supplied tool GUNZIP=$tool_specified" >&6;}
8601           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GUNZIP" >&5
8602 $as_echo_n "checking for GUNZIP... " >&6; }
8603           if test ! -x "$tool_specified"; then
8604             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8605 $as_echo "not found" >&6; }
8606             as_fn_error $? "User supplied tool GUNZIP=$tool_specified does not exist or is not executable" "$LINENO" 5
8607           fi
8608           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8609 $as_echo "$tool_specified" >&6; }
8610         fi
8611       fi
8612     fi
8613 
8614   fi
8615 
8616 
8617 
8618   if test "x$GUNZIP" = x; then
8619     as_fn_error $? "Could not find required tool for GUNZIP" "$LINENO" 5
8620   fi
8621 
8622 
8623 
8624 
8625 
8626   # Publish this variable in the help.
8627 
8628 
8629   if [ -z "${GZIP+x}" ]; then
8630     # The variable is not set by user, try to locate tool using the code snippet
8631     for ac_prog in pigz gzip
8632 do
8633   # Extract the first word of "$ac_prog", so it can be a program name with args.
8634 set dummy $ac_prog; ac_word=$2
8635 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8636 $as_echo_n "checking for $ac_word... " >&6; }
8637 if ${ac_cv_path_GZIP+:} false; then :
8638   $as_echo_n "(cached) " >&6
8639 else
8640   case $GZIP in
8641   [\\/]* | ?:[\\/]*)
8642   ac_cv_path_GZIP="$GZIP" # Let the user override the test with a path.
8643   ;;
8644   *)
8645   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8646 for as_dir in $PATH
8647 do
8648   IFS=$as_save_IFS
8649   test -z "$as_dir" && as_dir=.
8650     for ac_exec_ext in '' $ac_executable_extensions; do
8651   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8652     ac_cv_path_GZIP="$as_dir/$ac_word$ac_exec_ext"
8653     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8654     break 2
8655   fi
8656 done
8657   done
8658 IFS=$as_save_IFS
8659 
8660   ;;
8661 esac
8662 fi
8663 GZIP=$ac_cv_path_GZIP
8664 if test -n "$GZIP"; then
8665   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GZIP" >&5
8666 $as_echo "$GZIP" >&6; }
8667 else
8668   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8669 $as_echo "no" >&6; }
8670 fi
8671 
8672 
8673   test -n "$GZIP" && break
8674 done
8675 
8676   else
8677     # The variable is set, but is it from the command line or the environment?
8678 
8679     # Try to remove the string !GZIP! from our list.
8680     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!GZIP!/}
8681     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8682       # If it failed, the variable was not from the command line. Ignore it,
8683       # but warn the user (except for BASH, which is always set by the calling BASH).
8684       if test "xGZIP" != xBASH; then
8685         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of GZIP from the environment. Use command line variables instead." >&5
8686 $as_echo "$as_me: WARNING: Ignoring value of GZIP from the environment. Use command line variables instead." >&2;}
8687       fi
8688       # Try to locate tool using the code snippet
8689       for ac_prog in pigz gzip
8690 do
8691   # Extract the first word of "$ac_prog", so it can be a program name with args.
8692 set dummy $ac_prog; ac_word=$2
8693 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8694 $as_echo_n "checking for $ac_word... " >&6; }
8695 if ${ac_cv_path_GZIP+:} false; then :
8696   $as_echo_n "(cached) " >&6
8697 else
8698   case $GZIP in
8699   [\\/]* | ?:[\\/]*)
8700   ac_cv_path_GZIP="$GZIP" # Let the user override the test with a path.
8701   ;;
8702   *)
8703   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8704 for as_dir in $PATH
8705 do
8706   IFS=$as_save_IFS
8707   test -z "$as_dir" && as_dir=.
8708     for ac_exec_ext in '' $ac_executable_extensions; do
8709   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8710     ac_cv_path_GZIP="$as_dir/$ac_word$ac_exec_ext"
8711     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8712     break 2
8713   fi
8714 done
8715   done
8716 IFS=$as_save_IFS
8717 
8718   ;;
8719 esac
8720 fi
8721 GZIP=$ac_cv_path_GZIP
8722 if test -n "$GZIP"; then
8723   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GZIP" >&5
8724 $as_echo "$GZIP" >&6; }
8725 else
8726   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8727 $as_echo "no" >&6; }
8728 fi
8729 
8730 
8731   test -n "$GZIP" && break
8732 done
8733 
8734     else
8735       # If it succeeded, then it was overridden by the user. We will use it
8736       # for the tool.
8737 
8738       # First remove it from the list of overridden variables, so we can test
8739       # for unknown variables in the end.
8740       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8741 
8742       # Check if we try to supply an empty value
8743       if test "x$GZIP" = x; then
8744         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool GZIP= (no value)" >&5
8745 $as_echo "$as_me: Setting user supplied tool GZIP= (no value)" >&6;}
8746         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GZIP" >&5
8747 $as_echo_n "checking for GZIP... " >&6; }
8748         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
8749 $as_echo "disabled" >&6; }
8750       else
8751         # Check if the provided tool contains a complete path.
8752         tool_specified="$GZIP"
8753         tool_basename="${tool_specified##*/}"
8754         if test "x$tool_basename" = "x$tool_specified"; then
8755           # A command without a complete path is provided, search $PATH.
8756           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool GZIP=$tool_basename" >&5
8757 $as_echo "$as_me: Will search for user supplied tool GZIP=$tool_basename" >&6;}
8758           # Extract the first word of "$tool_basename", so it can be a program name with args.
8759 set dummy $tool_basename; ac_word=$2
8760 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8761 $as_echo_n "checking for $ac_word... " >&6; }
8762 if ${ac_cv_path_GZIP+:} false; then :
8763   $as_echo_n "(cached) " >&6
8764 else
8765   case $GZIP in
8766   [\\/]* | ?:[\\/]*)
8767   ac_cv_path_GZIP="$GZIP" # Let the user override the test with a path.
8768   ;;
8769   *)
8770   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8771 for as_dir in $PATH
8772 do
8773   IFS=$as_save_IFS
8774   test -z "$as_dir" && as_dir=.
8775     for ac_exec_ext in '' $ac_executable_extensions; do
8776   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8777     ac_cv_path_GZIP="$as_dir/$ac_word$ac_exec_ext"
8778     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8779     break 2
8780   fi
8781 done
8782   done
8783 IFS=$as_save_IFS
8784 
8785   ;;
8786 esac
8787 fi
8788 GZIP=$ac_cv_path_GZIP
8789 if test -n "$GZIP"; then
8790   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GZIP" >&5
8791 $as_echo "$GZIP" >&6; }
8792 else
8793   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8794 $as_echo "no" >&6; }
8795 fi
8796 
8797 
8798           if test "x$GZIP" = x; then
8799             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8800           fi
8801         else
8802           # Otherwise we believe it is a complete path. Use it as it is.
8803           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool GZIP=$tool_specified" >&5
8804 $as_echo "$as_me: Will use user supplied tool GZIP=$tool_specified" >&6;}
8805           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GZIP" >&5
8806 $as_echo_n "checking for GZIP... " >&6; }
8807           if test ! -x "$tool_specified"; then
8808             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8809 $as_echo "not found" >&6; }
8810             as_fn_error $? "User supplied tool GZIP=$tool_specified does not exist or is not executable" "$LINENO" 5
8811           fi
8812           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8813 $as_echo "$tool_specified" >&6; }
8814         fi
8815       fi
8816     fi
8817 
8818   fi
8819 
8820 
8821 
8822   if test "x$GZIP" = x; then
8823     as_fn_error $? "Could not find required tool for GZIP" "$LINENO" 5
8824   fi
8825 
8826 
8827 
8828 
8829 
8830   # Publish this variable in the help.
8831 
8832 
8833   if [ -z "${LN+x}" ]; then
8834     # The variable is not set by user, try to locate tool using the code snippet
8835     for ac_prog in ln
8836 do
8837   # Extract the first word of "$ac_prog", so it can be a program name with args.
8838 set dummy $ac_prog; ac_word=$2
8839 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8840 $as_echo_n "checking for $ac_word... " >&6; }
8841 if ${ac_cv_path_LN+:} false; then :
8842   $as_echo_n "(cached) " >&6
8843 else
8844   case $LN in
8845   [\\/]* | ?:[\\/]*)
8846   ac_cv_path_LN="$LN" # Let the user override the test with a path.
8847   ;;
8848   *)
8849   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8850 for as_dir in $PATH
8851 do
8852   IFS=$as_save_IFS
8853   test -z "$as_dir" && as_dir=.
8854     for ac_exec_ext in '' $ac_executable_extensions; do
8855   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8856     ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
8857     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8858     break 2
8859   fi
8860 done
8861   done
8862 IFS=$as_save_IFS
8863 
8864   ;;
8865 esac
8866 fi
8867 LN=$ac_cv_path_LN
8868 if test -n "$LN"; then
8869   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
8870 $as_echo "$LN" >&6; }
8871 else
8872   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8873 $as_echo "no" >&6; }
8874 fi
8875 
8876 
8877   test -n "$LN" && break
8878 done
8879 
8880   else
8881     # The variable is set, but is it from the command line or the environment?
8882 
8883     # Try to remove the string !LN! from our list.
8884     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LN!/}
8885     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8886       # If it failed, the variable was not from the command line. Ignore it,
8887       # but warn the user (except for BASH, which is always set by the calling BASH).
8888       if test "xLN" != xBASH; then
8889         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LN from the environment. Use command line variables instead." >&5
8890 $as_echo "$as_me: WARNING: Ignoring value of LN from the environment. Use command line variables instead." >&2;}
8891       fi
8892       # Try to locate tool using the code snippet
8893       for ac_prog in ln
8894 do
8895   # Extract the first word of "$ac_prog", so it can be a program name with args.
8896 set dummy $ac_prog; ac_word=$2
8897 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8898 $as_echo_n "checking for $ac_word... " >&6; }
8899 if ${ac_cv_path_LN+:} false; then :
8900   $as_echo_n "(cached) " >&6
8901 else
8902   case $LN in
8903   [\\/]* | ?:[\\/]*)
8904   ac_cv_path_LN="$LN" # Let the user override the test with a path.
8905   ;;
8906   *)
8907   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8908 for as_dir in $PATH
8909 do
8910   IFS=$as_save_IFS
8911   test -z "$as_dir" && as_dir=.
8912     for ac_exec_ext in '' $ac_executable_extensions; do
8913   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8914     ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
8915     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8916     break 2
8917   fi
8918 done
8919   done
8920 IFS=$as_save_IFS
8921 
8922   ;;
8923 esac
8924 fi
8925 LN=$ac_cv_path_LN
8926 if test -n "$LN"; then
8927   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
8928 $as_echo "$LN" >&6; }
8929 else
8930   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8931 $as_echo "no" >&6; }
8932 fi
8933 
8934 
8935   test -n "$LN" && break
8936 done
8937 
8938     else
8939       # If it succeeded, then it was overridden by the user. We will use it
8940       # for the tool.
8941 
8942       # First remove it from the list of overridden variables, so we can test
8943       # for unknown variables in the end.
8944       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8945 
8946       # Check if we try to supply an empty value
8947       if test "x$LN" = x; then
8948         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool LN= (no value)" >&5
8949 $as_echo "$as_me: Setting user supplied tool LN= (no value)" >&6;}
8950         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LN" >&5
8951 $as_echo_n "checking for LN... " >&6; }
8952         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
8953 $as_echo "disabled" >&6; }
8954       else
8955         # Check if the provided tool contains a complete path.
8956         tool_specified="$LN"
8957         tool_basename="${tool_specified##*/}"
8958         if test "x$tool_basename" = "x$tool_specified"; then
8959           # A command without a complete path is provided, search $PATH.
8960           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LN=$tool_basename" >&5
8961 $as_echo "$as_me: Will search for user supplied tool LN=$tool_basename" >&6;}
8962           # Extract the first word of "$tool_basename", so it can be a program name with args.
8963 set dummy $tool_basename; ac_word=$2
8964 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8965 $as_echo_n "checking for $ac_word... " >&6; }
8966 if ${ac_cv_path_LN+:} false; then :
8967   $as_echo_n "(cached) " >&6
8968 else
8969   case $LN in
8970   [\\/]* | ?:[\\/]*)
8971   ac_cv_path_LN="$LN" # Let the user override the test with a path.
8972   ;;
8973   *)
8974   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8975 for as_dir in $PATH
8976 do
8977   IFS=$as_save_IFS
8978   test -z "$as_dir" && as_dir=.
8979     for ac_exec_ext in '' $ac_executable_extensions; do
8980   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8981     ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
8982     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8983     break 2
8984   fi
8985 done
8986   done
8987 IFS=$as_save_IFS
8988 
8989   ;;
8990 esac
8991 fi
8992 LN=$ac_cv_path_LN
8993 if test -n "$LN"; then
8994   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
8995 $as_echo "$LN" >&6; }
8996 else
8997   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8998 $as_echo "no" >&6; }
8999 fi
9000 
9001 
9002           if test "x$LN" = x; then
9003             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9004           fi
9005         else
9006           # Otherwise we believe it is a complete path. Use it as it is.
9007           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LN=$tool_specified" >&5
9008 $as_echo "$as_me: Will use user supplied tool LN=$tool_specified" >&6;}
9009           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LN" >&5
9010 $as_echo_n "checking for LN... " >&6; }
9011           if test ! -x "$tool_specified"; then
9012             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9013 $as_echo "not found" >&6; }
9014             as_fn_error $? "User supplied tool LN=$tool_specified does not exist or is not executable" "$LINENO" 5
9015           fi
9016           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9017 $as_echo "$tool_specified" >&6; }
9018         fi
9019       fi
9020     fi
9021 
9022   fi
9023 
9024 
9025 
9026   if test "x$LN" = x; then
9027     as_fn_error $? "Could not find required tool for LN" "$LINENO" 5
9028   fi
9029 
9030 
9031 
9032 
9033 
9034   # Publish this variable in the help.
9035 
9036 
9037   if [ -z "${LS+x}" ]; then
9038     # The variable is not set by user, try to locate tool using the code snippet
9039     for ac_prog in ls
9040 do
9041   # Extract the first word of "$ac_prog", so it can be a program name with args.
9042 set dummy $ac_prog; ac_word=$2
9043 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9044 $as_echo_n "checking for $ac_word... " >&6; }
9045 if ${ac_cv_path_LS+:} false; then :
9046   $as_echo_n "(cached) " >&6
9047 else
9048   case $LS in
9049   [\\/]* | ?:[\\/]*)
9050   ac_cv_path_LS="$LS" # Let the user override the test with a path.
9051   ;;
9052   *)
9053   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9054 for as_dir in $PATH
9055 do
9056   IFS=$as_save_IFS
9057   test -z "$as_dir" && as_dir=.
9058     for ac_exec_ext in '' $ac_executable_extensions; do
9059   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9060     ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
9061     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9062     break 2
9063   fi
9064 done
9065   done
9066 IFS=$as_save_IFS
9067 
9068   ;;
9069 esac
9070 fi
9071 LS=$ac_cv_path_LS
9072 if test -n "$LS"; then
9073   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
9074 $as_echo "$LS" >&6; }
9075 else
9076   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9077 $as_echo "no" >&6; }
9078 fi
9079 
9080 
9081   test -n "$LS" && break
9082 done
9083 
9084   else
9085     # The variable is set, but is it from the command line or the environment?
9086 
9087     # Try to remove the string !LS! from our list.
9088     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LS!/}
9089     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9090       # If it failed, the variable was not from the command line. Ignore it,
9091       # but warn the user (except for BASH, which is always set by the calling BASH).
9092       if test "xLS" != xBASH; then
9093         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LS from the environment. Use command line variables instead." >&5
9094 $as_echo "$as_me: WARNING: Ignoring value of LS from the environment. Use command line variables instead." >&2;}
9095       fi
9096       # Try to locate tool using the code snippet
9097       for ac_prog in ls
9098 do
9099   # Extract the first word of "$ac_prog", so it can be a program name with args.
9100 set dummy $ac_prog; ac_word=$2
9101 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9102 $as_echo_n "checking for $ac_word... " >&6; }
9103 if ${ac_cv_path_LS+:} false; then :
9104   $as_echo_n "(cached) " >&6
9105 else
9106   case $LS in
9107   [\\/]* | ?:[\\/]*)
9108   ac_cv_path_LS="$LS" # Let the user override the test with a path.
9109   ;;
9110   *)
9111   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9112 for as_dir in $PATH
9113 do
9114   IFS=$as_save_IFS
9115   test -z "$as_dir" && as_dir=.
9116     for ac_exec_ext in '' $ac_executable_extensions; do
9117   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9118     ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
9119     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9120     break 2
9121   fi
9122 done
9123   done
9124 IFS=$as_save_IFS
9125 
9126   ;;
9127 esac
9128 fi
9129 LS=$ac_cv_path_LS
9130 if test -n "$LS"; then
9131   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
9132 $as_echo "$LS" >&6; }
9133 else
9134   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9135 $as_echo "no" >&6; }
9136 fi
9137 
9138 
9139   test -n "$LS" && break
9140 done
9141 
9142     else
9143       # If it succeeded, then it was overridden by the user. We will use it
9144       # for the tool.
9145 
9146       # First remove it from the list of overridden variables, so we can test
9147       # for unknown variables in the end.
9148       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9149 
9150       # Check if we try to supply an empty value
9151       if test "x$LS" = x; then
9152         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool LS= (no value)" >&5
9153 $as_echo "$as_me: Setting user supplied tool LS= (no value)" >&6;}
9154         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LS" >&5
9155 $as_echo_n "checking for LS... " >&6; }
9156         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
9157 $as_echo "disabled" >&6; }
9158       else
9159         # Check if the provided tool contains a complete path.
9160         tool_specified="$LS"
9161         tool_basename="${tool_specified##*/}"
9162         if test "x$tool_basename" = "x$tool_specified"; then
9163           # A command without a complete path is provided, search $PATH.
9164           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LS=$tool_basename" >&5
9165 $as_echo "$as_me: Will search for user supplied tool LS=$tool_basename" >&6;}
9166           # Extract the first word of "$tool_basename", so it can be a program name with args.
9167 set dummy $tool_basename; ac_word=$2
9168 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9169 $as_echo_n "checking for $ac_word... " >&6; }
9170 if ${ac_cv_path_LS+:} false; then :
9171   $as_echo_n "(cached) " >&6
9172 else
9173   case $LS in
9174   [\\/]* | ?:[\\/]*)
9175   ac_cv_path_LS="$LS" # Let the user override the test with a path.
9176   ;;
9177   *)
9178   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9179 for as_dir in $PATH
9180 do
9181   IFS=$as_save_IFS
9182   test -z "$as_dir" && as_dir=.
9183     for ac_exec_ext in '' $ac_executable_extensions; do
9184   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9185     ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
9186     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9187     break 2
9188   fi
9189 done
9190   done
9191 IFS=$as_save_IFS
9192 
9193   ;;
9194 esac
9195 fi
9196 LS=$ac_cv_path_LS
9197 if test -n "$LS"; then
9198   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
9199 $as_echo "$LS" >&6; }
9200 else
9201   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9202 $as_echo "no" >&6; }
9203 fi
9204 
9205 
9206           if test "x$LS" = x; then
9207             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9208           fi
9209         else
9210           # Otherwise we believe it is a complete path. Use it as it is.
9211           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LS=$tool_specified" >&5
9212 $as_echo "$as_me: Will use user supplied tool LS=$tool_specified" >&6;}
9213           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LS" >&5
9214 $as_echo_n "checking for LS... " >&6; }
9215           if test ! -x "$tool_specified"; then
9216             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9217 $as_echo "not found" >&6; }
9218             as_fn_error $? "User supplied tool LS=$tool_specified does not exist or is not executable" "$LINENO" 5
9219           fi
9220           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9221 $as_echo "$tool_specified" >&6; }
9222         fi
9223       fi
9224     fi
9225 
9226   fi
9227 
9228 
9229 
9230   if test "x$LS" = x; then
9231     as_fn_error $? "Could not find required tool for LS" "$LINENO" 5
9232   fi
9233 
9234 
9235 
9236 
9237 
9238   # Publish this variable in the help.
9239 
9240 
9241   if [ -z "${MKDIR+x}" ]; then
9242     # The variable is not set by user, try to locate tool using the code snippet
9243     for ac_prog in mkdir
9244 do
9245   # Extract the first word of "$ac_prog", so it can be a program name with args.
9246 set dummy $ac_prog; ac_word=$2
9247 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9248 $as_echo_n "checking for $ac_word... " >&6; }
9249 if ${ac_cv_path_MKDIR+:} false; then :
9250   $as_echo_n "(cached) " >&6
9251 else
9252   case $MKDIR in
9253   [\\/]* | ?:[\\/]*)
9254   ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
9255   ;;
9256   *)
9257   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9258 for as_dir in $PATH
9259 do
9260   IFS=$as_save_IFS
9261   test -z "$as_dir" && as_dir=.
9262     for ac_exec_ext in '' $ac_executable_extensions; do
9263   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9264     ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
9265     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9266     break 2
9267   fi
9268 done
9269   done
9270 IFS=$as_save_IFS
9271 
9272   ;;
9273 esac
9274 fi
9275 MKDIR=$ac_cv_path_MKDIR
9276 if test -n "$MKDIR"; then
9277   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
9278 $as_echo "$MKDIR" >&6; }
9279 else
9280   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9281 $as_echo "no" >&6; }
9282 fi
9283 
9284 
9285   test -n "$MKDIR" && break
9286 done
9287 
9288   else
9289     # The variable is set, but is it from the command line or the environment?
9290 
9291     # Try to remove the string !MKDIR! from our list.
9292     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MKDIR!/}
9293     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9294       # If it failed, the variable was not from the command line. Ignore it,
9295       # but warn the user (except for BASH, which is always set by the calling BASH).
9296       if test "xMKDIR" != xBASH; then
9297         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MKDIR from the environment. Use command line variables instead." >&5
9298 $as_echo "$as_me: WARNING: Ignoring value of MKDIR from the environment. Use command line variables instead." >&2;}
9299       fi
9300       # Try to locate tool using the code snippet
9301       for ac_prog in mkdir
9302 do
9303   # Extract the first word of "$ac_prog", so it can be a program name with args.
9304 set dummy $ac_prog; ac_word=$2
9305 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9306 $as_echo_n "checking for $ac_word... " >&6; }
9307 if ${ac_cv_path_MKDIR+:} false; then :
9308   $as_echo_n "(cached) " >&6
9309 else
9310   case $MKDIR in
9311   [\\/]* | ?:[\\/]*)
9312   ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
9313   ;;
9314   *)
9315   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9316 for as_dir in $PATH
9317 do
9318   IFS=$as_save_IFS
9319   test -z "$as_dir" && as_dir=.
9320     for ac_exec_ext in '' $ac_executable_extensions; do
9321   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9322     ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
9323     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9324     break 2
9325   fi
9326 done
9327   done
9328 IFS=$as_save_IFS
9329 
9330   ;;
9331 esac
9332 fi
9333 MKDIR=$ac_cv_path_MKDIR
9334 if test -n "$MKDIR"; then
9335   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
9336 $as_echo "$MKDIR" >&6; }
9337 else
9338   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9339 $as_echo "no" >&6; }
9340 fi
9341 
9342 
9343   test -n "$MKDIR" && break
9344 done
9345 
9346     else
9347       # If it succeeded, then it was overridden by the user. We will use it
9348       # for the tool.
9349 
9350       # First remove it from the list of overridden variables, so we can test
9351       # for unknown variables in the end.
9352       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9353 
9354       # Check if we try to supply an empty value
9355       if test "x$MKDIR" = x; then
9356         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool MKDIR= (no value)" >&5
9357 $as_echo "$as_me: Setting user supplied tool MKDIR= (no value)" >&6;}
9358         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKDIR" >&5
9359 $as_echo_n "checking for MKDIR... " >&6; }
9360         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
9361 $as_echo "disabled" >&6; }
9362       else
9363         # Check if the provided tool contains a complete path.
9364         tool_specified="$MKDIR"
9365         tool_basename="${tool_specified##*/}"
9366         if test "x$tool_basename" = "x$tool_specified"; then
9367           # A command without a complete path is provided, search $PATH.
9368           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MKDIR=$tool_basename" >&5
9369 $as_echo "$as_me: Will search for user supplied tool MKDIR=$tool_basename" >&6;}
9370           # Extract the first word of "$tool_basename", so it can be a program name with args.
9371 set dummy $tool_basename; ac_word=$2
9372 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9373 $as_echo_n "checking for $ac_word... " >&6; }
9374 if ${ac_cv_path_MKDIR+:} false; then :
9375   $as_echo_n "(cached) " >&6
9376 else
9377   case $MKDIR in
9378   [\\/]* | ?:[\\/]*)
9379   ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
9380   ;;
9381   *)
9382   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9383 for as_dir in $PATH
9384 do
9385   IFS=$as_save_IFS
9386   test -z "$as_dir" && as_dir=.
9387     for ac_exec_ext in '' $ac_executable_extensions; do
9388   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9389     ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
9390     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9391     break 2
9392   fi
9393 done
9394   done
9395 IFS=$as_save_IFS
9396 
9397   ;;
9398 esac
9399 fi
9400 MKDIR=$ac_cv_path_MKDIR
9401 if test -n "$MKDIR"; then
9402   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
9403 $as_echo "$MKDIR" >&6; }
9404 else
9405   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9406 $as_echo "no" >&6; }
9407 fi
9408 
9409 
9410           if test "x$MKDIR" = x; then
9411             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9412           fi
9413         else
9414           # Otherwise we believe it is a complete path. Use it as it is.
9415           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MKDIR=$tool_specified" >&5
9416 $as_echo "$as_me: Will use user supplied tool MKDIR=$tool_specified" >&6;}
9417           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKDIR" >&5
9418 $as_echo_n "checking for MKDIR... " >&6; }
9419           if test ! -x "$tool_specified"; then
9420             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9421 $as_echo "not found" >&6; }
9422             as_fn_error $? "User supplied tool MKDIR=$tool_specified does not exist or is not executable" "$LINENO" 5
9423           fi
9424           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9425 $as_echo "$tool_specified" >&6; }
9426         fi
9427       fi
9428     fi
9429 
9430   fi
9431 
9432 
9433 
9434   if test "x$MKDIR" = x; then
9435     as_fn_error $? "Could not find required tool for MKDIR" "$LINENO" 5
9436   fi
9437 
9438 
9439 
9440 
9441 
9442   # Publish this variable in the help.
9443 
9444 
9445   if [ -z "${MKTEMP+x}" ]; then
9446     # The variable is not set by user, try to locate tool using the code snippet
9447     for ac_prog in mktemp
9448 do
9449   # Extract the first word of "$ac_prog", so it can be a program name with args.
9450 set dummy $ac_prog; ac_word=$2
9451 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9452 $as_echo_n "checking for $ac_word... " >&6; }
9453 if ${ac_cv_path_MKTEMP+:} false; then :
9454   $as_echo_n "(cached) " >&6
9455 else
9456   case $MKTEMP in
9457   [\\/]* | ?:[\\/]*)
9458   ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
9459   ;;
9460   *)
9461   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9462 for as_dir in $PATH
9463 do
9464   IFS=$as_save_IFS
9465   test -z "$as_dir" && as_dir=.
9466     for ac_exec_ext in '' $ac_executable_extensions; do
9467   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9468     ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
9469     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9470     break 2
9471   fi
9472 done
9473   done
9474 IFS=$as_save_IFS
9475 
9476   ;;
9477 esac
9478 fi
9479 MKTEMP=$ac_cv_path_MKTEMP
9480 if test -n "$MKTEMP"; then
9481   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
9482 $as_echo "$MKTEMP" >&6; }
9483 else
9484   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9485 $as_echo "no" >&6; }
9486 fi
9487 
9488 
9489   test -n "$MKTEMP" && break
9490 done
9491 
9492   else
9493     # The variable is set, but is it from the command line or the environment?
9494 
9495     # Try to remove the string !MKTEMP! from our list.
9496     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MKTEMP!/}
9497     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9498       # If it failed, the variable was not from the command line. Ignore it,
9499       # but warn the user (except for BASH, which is always set by the calling BASH).
9500       if test "xMKTEMP" != xBASH; then
9501         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MKTEMP from the environment. Use command line variables instead." >&5
9502 $as_echo "$as_me: WARNING: Ignoring value of MKTEMP from the environment. Use command line variables instead." >&2;}
9503       fi
9504       # Try to locate tool using the code snippet
9505       for ac_prog in mktemp
9506 do
9507   # Extract the first word of "$ac_prog", so it can be a program name with args.
9508 set dummy $ac_prog; ac_word=$2
9509 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9510 $as_echo_n "checking for $ac_word... " >&6; }
9511 if ${ac_cv_path_MKTEMP+:} false; then :
9512   $as_echo_n "(cached) " >&6
9513 else
9514   case $MKTEMP in
9515   [\\/]* | ?:[\\/]*)
9516   ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
9517   ;;
9518   *)
9519   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9520 for as_dir in $PATH
9521 do
9522   IFS=$as_save_IFS
9523   test -z "$as_dir" && as_dir=.
9524     for ac_exec_ext in '' $ac_executable_extensions; do
9525   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9526     ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
9527     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9528     break 2
9529   fi
9530 done
9531   done
9532 IFS=$as_save_IFS
9533 
9534   ;;
9535 esac
9536 fi
9537 MKTEMP=$ac_cv_path_MKTEMP
9538 if test -n "$MKTEMP"; then
9539   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
9540 $as_echo "$MKTEMP" >&6; }
9541 else
9542   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9543 $as_echo "no" >&6; }
9544 fi
9545 
9546 
9547   test -n "$MKTEMP" && break
9548 done
9549 
9550     else
9551       # If it succeeded, then it was overridden by the user. We will use it
9552       # for the tool.
9553 
9554       # First remove it from the list of overridden variables, so we can test
9555       # for unknown variables in the end.
9556       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9557 
9558       # Check if we try to supply an empty value
9559       if test "x$MKTEMP" = x; then
9560         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool MKTEMP= (no value)" >&5
9561 $as_echo "$as_me: Setting user supplied tool MKTEMP= (no value)" >&6;}
9562         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKTEMP" >&5
9563 $as_echo_n "checking for MKTEMP... " >&6; }
9564         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
9565 $as_echo "disabled" >&6; }
9566       else
9567         # Check if the provided tool contains a complete path.
9568         tool_specified="$MKTEMP"
9569         tool_basename="${tool_specified##*/}"
9570         if test "x$tool_basename" = "x$tool_specified"; then
9571           # A command without a complete path is provided, search $PATH.
9572           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MKTEMP=$tool_basename" >&5
9573 $as_echo "$as_me: Will search for user supplied tool MKTEMP=$tool_basename" >&6;}
9574           # Extract the first word of "$tool_basename", so it can be a program name with args.
9575 set dummy $tool_basename; ac_word=$2
9576 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9577 $as_echo_n "checking for $ac_word... " >&6; }
9578 if ${ac_cv_path_MKTEMP+:} false; then :
9579   $as_echo_n "(cached) " >&6
9580 else
9581   case $MKTEMP in
9582   [\\/]* | ?:[\\/]*)
9583   ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
9584   ;;
9585   *)
9586   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9587 for as_dir in $PATH
9588 do
9589   IFS=$as_save_IFS
9590   test -z "$as_dir" && as_dir=.
9591     for ac_exec_ext in '' $ac_executable_extensions; do
9592   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9593     ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
9594     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9595     break 2
9596   fi
9597 done
9598   done
9599 IFS=$as_save_IFS
9600 
9601   ;;
9602 esac
9603 fi
9604 MKTEMP=$ac_cv_path_MKTEMP
9605 if test -n "$MKTEMP"; then
9606   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
9607 $as_echo "$MKTEMP" >&6; }
9608 else
9609   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9610 $as_echo "no" >&6; }
9611 fi
9612 
9613 
9614           if test "x$MKTEMP" = x; then
9615             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9616           fi
9617         else
9618           # Otherwise we believe it is a complete path. Use it as it is.
9619           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MKTEMP=$tool_specified" >&5
9620 $as_echo "$as_me: Will use user supplied tool MKTEMP=$tool_specified" >&6;}
9621           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKTEMP" >&5
9622 $as_echo_n "checking for MKTEMP... " >&6; }
9623           if test ! -x "$tool_specified"; then
9624             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9625 $as_echo "not found" >&6; }
9626             as_fn_error $? "User supplied tool MKTEMP=$tool_specified does not exist or is not executable" "$LINENO" 5
9627           fi
9628           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9629 $as_echo "$tool_specified" >&6; }
9630         fi
9631       fi
9632     fi
9633 
9634   fi
9635 
9636 
9637 
9638   if test "x$MKTEMP" = x; then
9639     as_fn_error $? "Could not find required tool for MKTEMP" "$LINENO" 5
9640   fi
9641 
9642 
9643 
9644 
9645 
9646   # Publish this variable in the help.
9647 
9648 
9649   if [ -z "${MV+x}" ]; then
9650     # The variable is not set by user, try to locate tool using the code snippet
9651     for ac_prog in mv
9652 do
9653   # Extract the first word of "$ac_prog", so it can be a program name with args.
9654 set dummy $ac_prog; ac_word=$2
9655 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9656 $as_echo_n "checking for $ac_word... " >&6; }
9657 if ${ac_cv_path_MV+:} false; then :
9658   $as_echo_n "(cached) " >&6
9659 else
9660   case $MV in
9661   [\\/]* | ?:[\\/]*)
9662   ac_cv_path_MV="$MV" # Let the user override the test with a path.
9663   ;;
9664   *)
9665   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9666 for as_dir in $PATH
9667 do
9668   IFS=$as_save_IFS
9669   test -z "$as_dir" && as_dir=.
9670     for ac_exec_ext in '' $ac_executable_extensions; do
9671   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9672     ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
9673     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9674     break 2
9675   fi
9676 done
9677   done
9678 IFS=$as_save_IFS
9679 
9680   ;;
9681 esac
9682 fi
9683 MV=$ac_cv_path_MV
9684 if test -n "$MV"; then
9685   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
9686 $as_echo "$MV" >&6; }
9687 else
9688   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9689 $as_echo "no" >&6; }
9690 fi
9691 
9692 
9693   test -n "$MV" && break
9694 done
9695 
9696   else
9697     # The variable is set, but is it from the command line or the environment?
9698 
9699     # Try to remove the string !MV! from our list.
9700     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MV!/}
9701     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9702       # If it failed, the variable was not from the command line. Ignore it,
9703       # but warn the user (except for BASH, which is always set by the calling BASH).
9704       if test "xMV" != xBASH; then
9705         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MV from the environment. Use command line variables instead." >&5
9706 $as_echo "$as_me: WARNING: Ignoring value of MV from the environment. Use command line variables instead." >&2;}
9707       fi
9708       # Try to locate tool using the code snippet
9709       for ac_prog in mv
9710 do
9711   # Extract the first word of "$ac_prog", so it can be a program name with args.
9712 set dummy $ac_prog; ac_word=$2
9713 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9714 $as_echo_n "checking for $ac_word... " >&6; }
9715 if ${ac_cv_path_MV+:} false; then :
9716   $as_echo_n "(cached) " >&6
9717 else
9718   case $MV in
9719   [\\/]* | ?:[\\/]*)
9720   ac_cv_path_MV="$MV" # Let the user override the test with a path.
9721   ;;
9722   *)
9723   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9724 for as_dir in $PATH
9725 do
9726   IFS=$as_save_IFS
9727   test -z "$as_dir" && as_dir=.
9728     for ac_exec_ext in '' $ac_executable_extensions; do
9729   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9730     ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
9731     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9732     break 2
9733   fi
9734 done
9735   done
9736 IFS=$as_save_IFS
9737 
9738   ;;
9739 esac
9740 fi
9741 MV=$ac_cv_path_MV
9742 if test -n "$MV"; then
9743   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
9744 $as_echo "$MV" >&6; }
9745 else
9746   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9747 $as_echo "no" >&6; }
9748 fi
9749 
9750 
9751   test -n "$MV" && break
9752 done
9753 
9754     else
9755       # If it succeeded, then it was overridden by the user. We will use it
9756       # for the tool.
9757 
9758       # First remove it from the list of overridden variables, so we can test
9759       # for unknown variables in the end.
9760       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9761 
9762       # Check if we try to supply an empty value
9763       if test "x$MV" = x; then
9764         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool MV= (no value)" >&5
9765 $as_echo "$as_me: Setting user supplied tool MV= (no value)" >&6;}
9766         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MV" >&5
9767 $as_echo_n "checking for MV... " >&6; }
9768         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
9769 $as_echo "disabled" >&6; }
9770       else
9771         # Check if the provided tool contains a complete path.
9772         tool_specified="$MV"
9773         tool_basename="${tool_specified##*/}"
9774         if test "x$tool_basename" = "x$tool_specified"; then
9775           # A command without a complete path is provided, search $PATH.
9776           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MV=$tool_basename" >&5
9777 $as_echo "$as_me: Will search for user supplied tool MV=$tool_basename" >&6;}
9778           # Extract the first word of "$tool_basename", so it can be a program name with args.
9779 set dummy $tool_basename; ac_word=$2
9780 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9781 $as_echo_n "checking for $ac_word... " >&6; }
9782 if ${ac_cv_path_MV+:} false; then :
9783   $as_echo_n "(cached) " >&6
9784 else
9785   case $MV in
9786   [\\/]* | ?:[\\/]*)
9787   ac_cv_path_MV="$MV" # Let the user override the test with a path.
9788   ;;
9789   *)
9790   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9791 for as_dir in $PATH
9792 do
9793   IFS=$as_save_IFS
9794   test -z "$as_dir" && as_dir=.
9795     for ac_exec_ext in '' $ac_executable_extensions; do
9796   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9797     ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
9798     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9799     break 2
9800   fi
9801 done
9802   done
9803 IFS=$as_save_IFS
9804 
9805   ;;
9806 esac
9807 fi
9808 MV=$ac_cv_path_MV
9809 if test -n "$MV"; then
9810   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
9811 $as_echo "$MV" >&6; }
9812 else
9813   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9814 $as_echo "no" >&6; }
9815 fi
9816 
9817 
9818           if test "x$MV" = x; then
9819             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9820           fi
9821         else
9822           # Otherwise we believe it is a complete path. Use it as it is.
9823           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MV=$tool_specified" >&5
9824 $as_echo "$as_me: Will use user supplied tool MV=$tool_specified" >&6;}
9825           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MV" >&5
9826 $as_echo_n "checking for MV... " >&6; }
9827           if test ! -x "$tool_specified"; then
9828             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9829 $as_echo "not found" >&6; }
9830             as_fn_error $? "User supplied tool MV=$tool_specified does not exist or is not executable" "$LINENO" 5
9831           fi
9832           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9833 $as_echo "$tool_specified" >&6; }
9834         fi
9835       fi
9836     fi
9837 
9838   fi
9839 
9840 
9841 
9842   if test "x$MV" = x; then
9843     as_fn_error $? "Could not find required tool for MV" "$LINENO" 5
9844   fi
9845 
9846 
9847 
9848 
9849 
9850   # Publish this variable in the help.
9851 
9852 
9853   if [ -z "${NAWK+x}" ]; then
9854     # The variable is not set by user, try to locate tool using the code snippet
9855     for ac_prog in nawk gawk awk
9856 do
9857   # Extract the first word of "$ac_prog", so it can be a program name with args.
9858 set dummy $ac_prog; ac_word=$2
9859 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9860 $as_echo_n "checking for $ac_word... " >&6; }
9861 if ${ac_cv_path_NAWK+:} false; then :
9862   $as_echo_n "(cached) " >&6
9863 else
9864   case $NAWK in
9865   [\\/]* | ?:[\\/]*)
9866   ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
9867   ;;
9868   *)
9869   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9870 for as_dir in $PATH
9871 do
9872   IFS=$as_save_IFS
9873   test -z "$as_dir" && as_dir=.
9874     for ac_exec_ext in '' $ac_executable_extensions; do
9875   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9876     ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
9877     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9878     break 2
9879   fi
9880 done
9881   done
9882 IFS=$as_save_IFS
9883 
9884   ;;
9885 esac
9886 fi
9887 NAWK=$ac_cv_path_NAWK
9888 if test -n "$NAWK"; then
9889   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
9890 $as_echo "$NAWK" >&6; }
9891 else
9892   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9893 $as_echo "no" >&6; }
9894 fi
9895 
9896 
9897   test -n "$NAWK" && break
9898 done
9899 
9900   else
9901     # The variable is set, but is it from the command line or the environment?
9902 
9903     # Try to remove the string !NAWK! from our list.
9904     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!NAWK!/}
9905     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9906       # If it failed, the variable was not from the command line. Ignore it,
9907       # but warn the user (except for BASH, which is always set by the calling BASH).
9908       if test "xNAWK" != xBASH; then
9909         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of NAWK from the environment. Use command line variables instead." >&5
9910 $as_echo "$as_me: WARNING: Ignoring value of NAWK from the environment. Use command line variables instead." >&2;}
9911       fi
9912       # Try to locate tool using the code snippet
9913       for ac_prog in nawk gawk awk
9914 do
9915   # Extract the first word of "$ac_prog", so it can be a program name with args.
9916 set dummy $ac_prog; ac_word=$2
9917 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9918 $as_echo_n "checking for $ac_word... " >&6; }
9919 if ${ac_cv_path_NAWK+:} false; then :
9920   $as_echo_n "(cached) " >&6
9921 else
9922   case $NAWK in
9923   [\\/]* | ?:[\\/]*)
9924   ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
9925   ;;
9926   *)
9927   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9928 for as_dir in $PATH
9929 do
9930   IFS=$as_save_IFS
9931   test -z "$as_dir" && as_dir=.
9932     for ac_exec_ext in '' $ac_executable_extensions; do
9933   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9934     ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
9935     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9936     break 2
9937   fi
9938 done
9939   done
9940 IFS=$as_save_IFS
9941 
9942   ;;
9943 esac
9944 fi
9945 NAWK=$ac_cv_path_NAWK
9946 if test -n "$NAWK"; then
9947   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
9948 $as_echo "$NAWK" >&6; }
9949 else
9950   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9951 $as_echo "no" >&6; }
9952 fi
9953 
9954 
9955   test -n "$NAWK" && break
9956 done
9957 
9958     else
9959       # If it succeeded, then it was overridden by the user. We will use it
9960       # for the tool.
9961 
9962       # First remove it from the list of overridden variables, so we can test
9963       # for unknown variables in the end.
9964       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9965 
9966       # Check if we try to supply an empty value
9967       if test "x$NAWK" = x; then
9968         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool NAWK= (no value)" >&5
9969 $as_echo "$as_me: Setting user supplied tool NAWK= (no value)" >&6;}
9970         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NAWK" >&5
9971 $as_echo_n "checking for NAWK... " >&6; }
9972         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
9973 $as_echo "disabled" >&6; }
9974       else
9975         # Check if the provided tool contains a complete path.
9976         tool_specified="$NAWK"
9977         tool_basename="${tool_specified##*/}"
9978         if test "x$tool_basename" = "x$tool_specified"; then
9979           # A command without a complete path is provided, search $PATH.
9980           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool NAWK=$tool_basename" >&5
9981 $as_echo "$as_me: Will search for user supplied tool NAWK=$tool_basename" >&6;}
9982           # Extract the first word of "$tool_basename", so it can be a program name with args.
9983 set dummy $tool_basename; ac_word=$2
9984 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9985 $as_echo_n "checking for $ac_word... " >&6; }
9986 if ${ac_cv_path_NAWK+:} false; then :
9987   $as_echo_n "(cached) " >&6
9988 else
9989   case $NAWK in
9990   [\\/]* | ?:[\\/]*)
9991   ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
9992   ;;
9993   *)
9994   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9995 for as_dir in $PATH
9996 do
9997   IFS=$as_save_IFS
9998   test -z "$as_dir" && as_dir=.
9999     for ac_exec_ext in '' $ac_executable_extensions; do
10000   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10001     ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
10002     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10003     break 2
10004   fi
10005 done
10006   done
10007 IFS=$as_save_IFS
10008 
10009   ;;
10010 esac
10011 fi
10012 NAWK=$ac_cv_path_NAWK
10013 if test -n "$NAWK"; then
10014   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
10015 $as_echo "$NAWK" >&6; }
10016 else
10017   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10018 $as_echo "no" >&6; }
10019 fi
10020 
10021 
10022           if test "x$NAWK" = x; then
10023             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10024           fi
10025         else
10026           # Otherwise we believe it is a complete path. Use it as it is.
10027           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool NAWK=$tool_specified" >&5
10028 $as_echo "$as_me: Will use user supplied tool NAWK=$tool_specified" >&6;}
10029           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NAWK" >&5
10030 $as_echo_n "checking for NAWK... " >&6; }
10031           if test ! -x "$tool_specified"; then
10032             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10033 $as_echo "not found" >&6; }
10034             as_fn_error $? "User supplied tool NAWK=$tool_specified does not exist or is not executable" "$LINENO" 5
10035           fi
10036           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10037 $as_echo "$tool_specified" >&6; }
10038         fi
10039       fi
10040     fi
10041 
10042   fi
10043 
10044 
10045 
10046   if test "x$NAWK" = x; then
10047     as_fn_error $? "Could not find required tool for NAWK" "$LINENO" 5
10048   fi
10049 
10050 
10051 
10052 
10053 
10054   # Publish this variable in the help.
10055 
10056 
10057   if [ -z "${PRINTF+x}" ]; then
10058     # The variable is not set by user, try to locate tool using the code snippet
10059     for ac_prog in printf
10060 do
10061   # Extract the first word of "$ac_prog", so it can be a program name with args.
10062 set dummy $ac_prog; ac_word=$2
10063 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10064 $as_echo_n "checking for $ac_word... " >&6; }
10065 if ${ac_cv_path_PRINTF+:} false; then :
10066   $as_echo_n "(cached) " >&6
10067 else
10068   case $PRINTF in
10069   [\\/]* | ?:[\\/]*)
10070   ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
10071   ;;
10072   *)
10073   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10074 for as_dir in $PATH
10075 do
10076   IFS=$as_save_IFS
10077   test -z "$as_dir" && as_dir=.
10078     for ac_exec_ext in '' $ac_executable_extensions; do
10079   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10080     ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
10081     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10082     break 2
10083   fi
10084 done
10085   done
10086 IFS=$as_save_IFS
10087 
10088   ;;
10089 esac
10090 fi
10091 PRINTF=$ac_cv_path_PRINTF
10092 if test -n "$PRINTF"; then
10093   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
10094 $as_echo "$PRINTF" >&6; }
10095 else
10096   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10097 $as_echo "no" >&6; }
10098 fi
10099 
10100 
10101   test -n "$PRINTF" && break
10102 done
10103 
10104   else
10105     # The variable is set, but is it from the command line or the environment?
10106 
10107     # Try to remove the string !PRINTF! from our list.
10108     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!PRINTF!/}
10109     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10110       # If it failed, the variable was not from the command line. Ignore it,
10111       # but warn the user (except for BASH, which is always set by the calling BASH).
10112       if test "xPRINTF" != xBASH; then
10113         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of PRINTF from the environment. Use command line variables instead." >&5
10114 $as_echo "$as_me: WARNING: Ignoring value of PRINTF from the environment. Use command line variables instead." >&2;}
10115       fi
10116       # Try to locate tool using the code snippet
10117       for ac_prog in printf
10118 do
10119   # Extract the first word of "$ac_prog", so it can be a program name with args.
10120 set dummy $ac_prog; ac_word=$2
10121 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10122 $as_echo_n "checking for $ac_word... " >&6; }
10123 if ${ac_cv_path_PRINTF+:} false; then :
10124   $as_echo_n "(cached) " >&6
10125 else
10126   case $PRINTF in
10127   [\\/]* | ?:[\\/]*)
10128   ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
10129   ;;
10130   *)
10131   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10132 for as_dir in $PATH
10133 do
10134   IFS=$as_save_IFS
10135   test -z "$as_dir" && as_dir=.
10136     for ac_exec_ext in '' $ac_executable_extensions; do
10137   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10138     ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
10139     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10140     break 2
10141   fi
10142 done
10143   done
10144 IFS=$as_save_IFS
10145 
10146   ;;
10147 esac
10148 fi
10149 PRINTF=$ac_cv_path_PRINTF
10150 if test -n "$PRINTF"; then
10151   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
10152 $as_echo "$PRINTF" >&6; }
10153 else
10154   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10155 $as_echo "no" >&6; }
10156 fi
10157 
10158 
10159   test -n "$PRINTF" && break
10160 done
10161 
10162     else
10163       # If it succeeded, then it was overridden by the user. We will use it
10164       # for the tool.
10165 
10166       # First remove it from the list of overridden variables, so we can test
10167       # for unknown variables in the end.
10168       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10169 
10170       # Check if we try to supply an empty value
10171       if test "x$PRINTF" = x; then
10172         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool PRINTF= (no value)" >&5
10173 $as_echo "$as_me: Setting user supplied tool PRINTF= (no value)" >&6;}
10174         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PRINTF" >&5
10175 $as_echo_n "checking for PRINTF... " >&6; }
10176         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
10177 $as_echo "disabled" >&6; }
10178       else
10179         # Check if the provided tool contains a complete path.
10180         tool_specified="$PRINTF"
10181         tool_basename="${tool_specified##*/}"
10182         if test "x$tool_basename" = "x$tool_specified"; then
10183           # A command without a complete path is provided, search $PATH.
10184           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool PRINTF=$tool_basename" >&5
10185 $as_echo "$as_me: Will search for user supplied tool PRINTF=$tool_basename" >&6;}
10186           # Extract the first word of "$tool_basename", so it can be a program name with args.
10187 set dummy $tool_basename; ac_word=$2
10188 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10189 $as_echo_n "checking for $ac_word... " >&6; }
10190 if ${ac_cv_path_PRINTF+:} false; then :
10191   $as_echo_n "(cached) " >&6
10192 else
10193   case $PRINTF in
10194   [\\/]* | ?:[\\/]*)
10195   ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
10196   ;;
10197   *)
10198   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10199 for as_dir in $PATH
10200 do
10201   IFS=$as_save_IFS
10202   test -z "$as_dir" && as_dir=.
10203     for ac_exec_ext in '' $ac_executable_extensions; do
10204   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10205     ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
10206     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10207     break 2
10208   fi
10209 done
10210   done
10211 IFS=$as_save_IFS
10212 
10213   ;;
10214 esac
10215 fi
10216 PRINTF=$ac_cv_path_PRINTF
10217 if test -n "$PRINTF"; then
10218   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
10219 $as_echo "$PRINTF" >&6; }
10220 else
10221   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10222 $as_echo "no" >&6; }
10223 fi
10224 
10225 
10226           if test "x$PRINTF" = x; then
10227             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10228           fi
10229         else
10230           # Otherwise we believe it is a complete path. Use it as it is.
10231           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool PRINTF=$tool_specified" >&5
10232 $as_echo "$as_me: Will use user supplied tool PRINTF=$tool_specified" >&6;}
10233           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PRINTF" >&5
10234 $as_echo_n "checking for PRINTF... " >&6; }
10235           if test ! -x "$tool_specified"; then
10236             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10237 $as_echo "not found" >&6; }
10238             as_fn_error $? "User supplied tool PRINTF=$tool_specified does not exist or is not executable" "$LINENO" 5
10239           fi
10240           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10241 $as_echo "$tool_specified" >&6; }
10242         fi
10243       fi
10244     fi
10245 
10246   fi
10247 
10248 
10249 
10250   if test "x$PRINTF" = x; then
10251     as_fn_error $? "Could not find required tool for PRINTF" "$LINENO" 5
10252   fi
10253 
10254 
10255 
10256 
10257 
10258   # Publish this variable in the help.
10259 
10260 
10261   if [ -z "${RM+x}" ]; then
10262     # The variable is not set by user, try to locate tool using the code snippet
10263     for ac_prog in rm
10264 do
10265   # Extract the first word of "$ac_prog", so it can be a program name with args.
10266 set dummy $ac_prog; ac_word=$2
10267 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10268 $as_echo_n "checking for $ac_word... " >&6; }
10269 if ${ac_cv_path_RM+:} false; then :
10270   $as_echo_n "(cached) " >&6
10271 else
10272   case $RM in
10273   [\\/]* | ?:[\\/]*)
10274   ac_cv_path_RM="$RM" # Let the user override the test with a path.
10275   ;;
10276   *)
10277   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10278 for as_dir in $PATH
10279 do
10280   IFS=$as_save_IFS
10281   test -z "$as_dir" && as_dir=.
10282     for ac_exec_ext in '' $ac_executable_extensions; do
10283   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10284     ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
10285     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10286     break 2
10287   fi
10288 done
10289   done
10290 IFS=$as_save_IFS
10291 
10292   ;;
10293 esac
10294 fi
10295 RM=$ac_cv_path_RM
10296 if test -n "$RM"; then
10297   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
10298 $as_echo "$RM" >&6; }
10299 else
10300   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10301 $as_echo "no" >&6; }
10302 fi
10303 
10304 
10305   test -n "$RM" && break
10306 done
10307 
10308   else
10309     # The variable is set, but is it from the command line or the environment?
10310 
10311     # Try to remove the string !RM! from our list.
10312     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!RM!/}
10313     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10314       # If it failed, the variable was not from the command line. Ignore it,
10315       # but warn the user (except for BASH, which is always set by the calling BASH).
10316       if test "xRM" != xBASH; then
10317         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of RM from the environment. Use command line variables instead." >&5
10318 $as_echo "$as_me: WARNING: Ignoring value of RM from the environment. Use command line variables instead." >&2;}
10319       fi
10320       # Try to locate tool using the code snippet
10321       for ac_prog in rm
10322 do
10323   # Extract the first word of "$ac_prog", so it can be a program name with args.
10324 set dummy $ac_prog; ac_word=$2
10325 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10326 $as_echo_n "checking for $ac_word... " >&6; }
10327 if ${ac_cv_path_RM+:} false; then :
10328   $as_echo_n "(cached) " >&6
10329 else
10330   case $RM in
10331   [\\/]* | ?:[\\/]*)
10332   ac_cv_path_RM="$RM" # Let the user override the test with a path.
10333   ;;
10334   *)
10335   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10336 for as_dir in $PATH
10337 do
10338   IFS=$as_save_IFS
10339   test -z "$as_dir" && as_dir=.
10340     for ac_exec_ext in '' $ac_executable_extensions; do
10341   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10342     ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
10343     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10344     break 2
10345   fi
10346 done
10347   done
10348 IFS=$as_save_IFS
10349 
10350   ;;
10351 esac
10352 fi
10353 RM=$ac_cv_path_RM
10354 if test -n "$RM"; then
10355   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
10356 $as_echo "$RM" >&6; }
10357 else
10358   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10359 $as_echo "no" >&6; }
10360 fi
10361 
10362 
10363   test -n "$RM" && break
10364 done
10365 
10366     else
10367       # If it succeeded, then it was overridden by the user. We will use it
10368       # for the tool.
10369 
10370       # First remove it from the list of overridden variables, so we can test
10371       # for unknown variables in the end.
10372       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10373 
10374       # Check if we try to supply an empty value
10375       if test "x$RM" = x; then
10376         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool RM= (no value)" >&5
10377 $as_echo "$as_me: Setting user supplied tool RM= (no value)" >&6;}
10378         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for RM" >&5
10379 $as_echo_n "checking for RM... " >&6; }
10380         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
10381 $as_echo "disabled" >&6; }
10382       else
10383         # Check if the provided tool contains a complete path.
10384         tool_specified="$RM"
10385         tool_basename="${tool_specified##*/}"
10386         if test "x$tool_basename" = "x$tool_specified"; then
10387           # A command without a complete path is provided, search $PATH.
10388           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool RM=$tool_basename" >&5
10389 $as_echo "$as_me: Will search for user supplied tool RM=$tool_basename" >&6;}
10390           # Extract the first word of "$tool_basename", so it can be a program name with args.
10391 set dummy $tool_basename; ac_word=$2
10392 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10393 $as_echo_n "checking for $ac_word... " >&6; }
10394 if ${ac_cv_path_RM+:} false; then :
10395   $as_echo_n "(cached) " >&6
10396 else
10397   case $RM in
10398   [\\/]* | ?:[\\/]*)
10399   ac_cv_path_RM="$RM" # Let the user override the test with a path.
10400   ;;
10401   *)
10402   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10403 for as_dir in $PATH
10404 do
10405   IFS=$as_save_IFS
10406   test -z "$as_dir" && as_dir=.
10407     for ac_exec_ext in '' $ac_executable_extensions; do
10408   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10409     ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
10410     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10411     break 2
10412   fi
10413 done
10414   done
10415 IFS=$as_save_IFS
10416 
10417   ;;
10418 esac
10419 fi
10420 RM=$ac_cv_path_RM
10421 if test -n "$RM"; then
10422   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
10423 $as_echo "$RM" >&6; }
10424 else
10425   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10426 $as_echo "no" >&6; }
10427 fi
10428 
10429 
10430           if test "x$RM" = x; then
10431             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10432           fi
10433         else
10434           # Otherwise we believe it is a complete path. Use it as it is.
10435           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool RM=$tool_specified" >&5
10436 $as_echo "$as_me: Will use user supplied tool RM=$tool_specified" >&6;}
10437           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for RM" >&5
10438 $as_echo_n "checking for RM... " >&6; }
10439           if test ! -x "$tool_specified"; then
10440             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10441 $as_echo "not found" >&6; }
10442             as_fn_error $? "User supplied tool RM=$tool_specified does not exist or is not executable" "$LINENO" 5
10443           fi
10444           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10445 $as_echo "$tool_specified" >&6; }
10446         fi
10447       fi
10448     fi
10449 
10450   fi
10451 
10452 
10453 
10454   if test "x$RM" = x; then
10455     as_fn_error $? "Could not find required tool for RM" "$LINENO" 5
10456   fi
10457 
10458 
10459 
10460 
10461 
10462   # Publish this variable in the help.
10463 
10464 
10465   if [ -z "${RMDIR+x}" ]; then
10466     # The variable is not set by user, try to locate tool using the code snippet
10467     for ac_prog in rmdir
10468 do
10469   # Extract the first word of "$ac_prog", so it can be a program name with args.
10470 set dummy $ac_prog; ac_word=$2
10471 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10472 $as_echo_n "checking for $ac_word... " >&6; }
10473 if ${ac_cv_path_RMDIR+:} false; then :
10474   $as_echo_n "(cached) " >&6
10475 else
10476   case $RMDIR in
10477   [\\/]* | ?:[\\/]*)
10478   ac_cv_path_RMDIR="$RMDIR" # Let the user override the test with a path.
10479   ;;
10480   *)
10481   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10482 for as_dir in $PATH
10483 do
10484   IFS=$as_save_IFS
10485   test -z "$as_dir" && as_dir=.
10486     for ac_exec_ext in '' $ac_executable_extensions; do
10487   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10488     ac_cv_path_RMDIR="$as_dir/$ac_word$ac_exec_ext"
10489     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10490     break 2
10491   fi
10492 done
10493   done
10494 IFS=$as_save_IFS
10495 
10496   ;;
10497 esac
10498 fi
10499 RMDIR=$ac_cv_path_RMDIR
10500 if test -n "$RMDIR"; then
10501   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RMDIR" >&5
10502 $as_echo "$RMDIR" >&6; }
10503 else
10504   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10505 $as_echo "no" >&6; }
10506 fi
10507 
10508 
10509   test -n "$RMDIR" && break
10510 done
10511 
10512   else
10513     # The variable is set, but is it from the command line or the environment?
10514 
10515     # Try to remove the string !RMDIR! from our list.
10516     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!RMDIR!/}
10517     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10518       # If it failed, the variable was not from the command line. Ignore it,
10519       # but warn the user (except for BASH, which is always set by the calling BASH).
10520       if test "xRMDIR" != xBASH; then
10521         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of RMDIR from the environment. Use command line variables instead." >&5
10522 $as_echo "$as_me: WARNING: Ignoring value of RMDIR from the environment. Use command line variables instead." >&2;}
10523       fi
10524       # Try to locate tool using the code snippet
10525       for ac_prog in rmdir
10526 do
10527   # Extract the first word of "$ac_prog", so it can be a program name with args.
10528 set dummy $ac_prog; ac_word=$2
10529 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10530 $as_echo_n "checking for $ac_word... " >&6; }
10531 if ${ac_cv_path_RMDIR+:} false; then :
10532   $as_echo_n "(cached) " >&6
10533 else
10534   case $RMDIR in
10535   [\\/]* | ?:[\\/]*)
10536   ac_cv_path_RMDIR="$RMDIR" # Let the user override the test with a path.
10537   ;;
10538   *)
10539   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10540 for as_dir in $PATH
10541 do
10542   IFS=$as_save_IFS
10543   test -z "$as_dir" && as_dir=.
10544     for ac_exec_ext in '' $ac_executable_extensions; do
10545   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10546     ac_cv_path_RMDIR="$as_dir/$ac_word$ac_exec_ext"
10547     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10548     break 2
10549   fi
10550 done
10551   done
10552 IFS=$as_save_IFS
10553 
10554   ;;
10555 esac
10556 fi
10557 RMDIR=$ac_cv_path_RMDIR
10558 if test -n "$RMDIR"; then
10559   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RMDIR" >&5
10560 $as_echo "$RMDIR" >&6; }
10561 else
10562   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10563 $as_echo "no" >&6; }
10564 fi
10565 
10566 
10567   test -n "$RMDIR" && break
10568 done
10569 
10570     else
10571       # If it succeeded, then it was overridden by the user. We will use it
10572       # for the tool.
10573 
10574       # First remove it from the list of overridden variables, so we can test
10575       # for unknown variables in the end.
10576       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10577 
10578       # Check if we try to supply an empty value
10579       if test "x$RMDIR" = x; then
10580         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool RMDIR= (no value)" >&5
10581 $as_echo "$as_me: Setting user supplied tool RMDIR= (no value)" >&6;}
10582         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for RMDIR" >&5
10583 $as_echo_n "checking for RMDIR... " >&6; }
10584         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
10585 $as_echo "disabled" >&6; }
10586       else
10587         # Check if the provided tool contains a complete path.
10588         tool_specified="$RMDIR"
10589         tool_basename="${tool_specified##*/}"
10590         if test "x$tool_basename" = "x$tool_specified"; then
10591           # A command without a complete path is provided, search $PATH.
10592           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool RMDIR=$tool_basename" >&5
10593 $as_echo "$as_me: Will search for user supplied tool RMDIR=$tool_basename" >&6;}
10594           # Extract the first word of "$tool_basename", so it can be a program name with args.
10595 set dummy $tool_basename; ac_word=$2
10596 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10597 $as_echo_n "checking for $ac_word... " >&6; }
10598 if ${ac_cv_path_RMDIR+:} false; then :
10599   $as_echo_n "(cached) " >&6
10600 else
10601   case $RMDIR in
10602   [\\/]* | ?:[\\/]*)
10603   ac_cv_path_RMDIR="$RMDIR" # Let the user override the test with a path.
10604   ;;
10605   *)
10606   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10607 for as_dir in $PATH
10608 do
10609   IFS=$as_save_IFS
10610   test -z "$as_dir" && as_dir=.
10611     for ac_exec_ext in '' $ac_executable_extensions; do
10612   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10613     ac_cv_path_RMDIR="$as_dir/$ac_word$ac_exec_ext"
10614     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10615     break 2
10616   fi
10617 done
10618   done
10619 IFS=$as_save_IFS
10620 
10621   ;;
10622 esac
10623 fi
10624 RMDIR=$ac_cv_path_RMDIR
10625 if test -n "$RMDIR"; then
10626   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RMDIR" >&5
10627 $as_echo "$RMDIR" >&6; }
10628 else
10629   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10630 $as_echo "no" >&6; }
10631 fi
10632 
10633 
10634           if test "x$RMDIR" = x; then
10635             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10636           fi
10637         else
10638           # Otherwise we believe it is a complete path. Use it as it is.
10639           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool RMDIR=$tool_specified" >&5
10640 $as_echo "$as_me: Will use user supplied tool RMDIR=$tool_specified" >&6;}
10641           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for RMDIR" >&5
10642 $as_echo_n "checking for RMDIR... " >&6; }
10643           if test ! -x "$tool_specified"; then
10644             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10645 $as_echo "not found" >&6; }
10646             as_fn_error $? "User supplied tool RMDIR=$tool_specified does not exist or is not executable" "$LINENO" 5
10647           fi
10648           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10649 $as_echo "$tool_specified" >&6; }
10650         fi
10651       fi
10652     fi
10653 
10654   fi
10655 
10656 
10657 
10658   if test "x$RMDIR" = x; then
10659     as_fn_error $? "Could not find required tool for RMDIR" "$LINENO" 5
10660   fi
10661 
10662 
10663 
10664 
10665 
10666   # Publish this variable in the help.
10667 
10668 
10669   if [ -z "${SH+x}" ]; then
10670     # The variable is not set by user, try to locate tool using the code snippet
10671     for ac_prog in sh
10672 do
10673   # Extract the first word of "$ac_prog", so it can be a program name with args.
10674 set dummy $ac_prog; ac_word=$2
10675 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10676 $as_echo_n "checking for $ac_word... " >&6; }
10677 if ${ac_cv_path_SH+:} false; then :
10678   $as_echo_n "(cached) " >&6
10679 else
10680   case $SH in
10681   [\\/]* | ?:[\\/]*)
10682   ac_cv_path_SH="$SH" # Let the user override the test with a path.
10683   ;;
10684   *)
10685   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10686 for as_dir in $PATH
10687 do
10688   IFS=$as_save_IFS
10689   test -z "$as_dir" && as_dir=.
10690     for ac_exec_ext in '' $ac_executable_extensions; do
10691   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10692     ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
10693     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10694     break 2
10695   fi
10696 done
10697   done
10698 IFS=$as_save_IFS
10699 
10700   ;;
10701 esac
10702 fi
10703 SH=$ac_cv_path_SH
10704 if test -n "$SH"; then
10705   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
10706 $as_echo "$SH" >&6; }
10707 else
10708   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10709 $as_echo "no" >&6; }
10710 fi
10711 
10712 
10713   test -n "$SH" && break
10714 done
10715 
10716   else
10717     # The variable is set, but is it from the command line or the environment?
10718 
10719     # Try to remove the string !SH! from our list.
10720     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SH!/}
10721     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10722       # If it failed, the variable was not from the command line. Ignore it,
10723       # but warn the user (except for BASH, which is always set by the calling BASH).
10724       if test "xSH" != xBASH; then
10725         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SH from the environment. Use command line variables instead." >&5
10726 $as_echo "$as_me: WARNING: Ignoring value of SH from the environment. Use command line variables instead." >&2;}
10727       fi
10728       # Try to locate tool using the code snippet
10729       for ac_prog in sh
10730 do
10731   # Extract the first word of "$ac_prog", so it can be a program name with args.
10732 set dummy $ac_prog; ac_word=$2
10733 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10734 $as_echo_n "checking for $ac_word... " >&6; }
10735 if ${ac_cv_path_SH+:} false; then :
10736   $as_echo_n "(cached) " >&6
10737 else
10738   case $SH in
10739   [\\/]* | ?:[\\/]*)
10740   ac_cv_path_SH="$SH" # Let the user override the test with a path.
10741   ;;
10742   *)
10743   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10744 for as_dir in $PATH
10745 do
10746   IFS=$as_save_IFS
10747   test -z "$as_dir" && as_dir=.
10748     for ac_exec_ext in '' $ac_executable_extensions; do
10749   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10750     ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
10751     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10752     break 2
10753   fi
10754 done
10755   done
10756 IFS=$as_save_IFS
10757 
10758   ;;
10759 esac
10760 fi
10761 SH=$ac_cv_path_SH
10762 if test -n "$SH"; then
10763   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
10764 $as_echo "$SH" >&6; }
10765 else
10766   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10767 $as_echo "no" >&6; }
10768 fi
10769 
10770 
10771   test -n "$SH" && break
10772 done
10773 
10774     else
10775       # If it succeeded, then it was overridden by the user. We will use it
10776       # for the tool.
10777 
10778       # First remove it from the list of overridden variables, so we can test
10779       # for unknown variables in the end.
10780       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10781 
10782       # Check if we try to supply an empty value
10783       if test "x$SH" = x; then
10784         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool SH= (no value)" >&5
10785 $as_echo "$as_me: Setting user supplied tool SH= (no value)" >&6;}
10786         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SH" >&5
10787 $as_echo_n "checking for SH... " >&6; }
10788         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
10789 $as_echo "disabled" >&6; }
10790       else
10791         # Check if the provided tool contains a complete path.
10792         tool_specified="$SH"
10793         tool_basename="${tool_specified##*/}"
10794         if test "x$tool_basename" = "x$tool_specified"; then
10795           # A command without a complete path is provided, search $PATH.
10796           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SH=$tool_basename" >&5
10797 $as_echo "$as_me: Will search for user supplied tool SH=$tool_basename" >&6;}
10798           # Extract the first word of "$tool_basename", so it can be a program name with args.
10799 set dummy $tool_basename; ac_word=$2
10800 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10801 $as_echo_n "checking for $ac_word... " >&6; }
10802 if ${ac_cv_path_SH+:} false; then :
10803   $as_echo_n "(cached) " >&6
10804 else
10805   case $SH in
10806   [\\/]* | ?:[\\/]*)
10807   ac_cv_path_SH="$SH" # Let the user override the test with a path.
10808   ;;
10809   *)
10810   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10811 for as_dir in $PATH
10812 do
10813   IFS=$as_save_IFS
10814   test -z "$as_dir" && as_dir=.
10815     for ac_exec_ext in '' $ac_executable_extensions; do
10816   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10817     ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
10818     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10819     break 2
10820   fi
10821 done
10822   done
10823 IFS=$as_save_IFS
10824 
10825   ;;
10826 esac
10827 fi
10828 SH=$ac_cv_path_SH
10829 if test -n "$SH"; then
10830   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
10831 $as_echo "$SH" >&6; }
10832 else
10833   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10834 $as_echo "no" >&6; }
10835 fi
10836 
10837 
10838           if test "x$SH" = x; then
10839             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10840           fi
10841         else
10842           # Otherwise we believe it is a complete path. Use it as it is.
10843           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SH=$tool_specified" >&5
10844 $as_echo "$as_me: Will use user supplied tool SH=$tool_specified" >&6;}
10845           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SH" >&5
10846 $as_echo_n "checking for SH... " >&6; }
10847           if test ! -x "$tool_specified"; then
10848             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10849 $as_echo "not found" >&6; }
10850             as_fn_error $? "User supplied tool SH=$tool_specified does not exist or is not executable" "$LINENO" 5
10851           fi
10852           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10853 $as_echo "$tool_specified" >&6; }
10854         fi
10855       fi
10856     fi
10857 
10858   fi
10859 
10860 
10861 
10862   if test "x$SH" = x; then
10863     as_fn_error $? "Could not find required tool for SH" "$LINENO" 5
10864   fi
10865 
10866 
10867 
10868 
10869 
10870   # Publish this variable in the help.
10871 
10872 
10873   if [ -z "${SORT+x}" ]; then
10874     # The variable is not set by user, try to locate tool using the code snippet
10875     for ac_prog in sort
10876 do
10877   # Extract the first word of "$ac_prog", so it can be a program name with args.
10878 set dummy $ac_prog; ac_word=$2
10879 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10880 $as_echo_n "checking for $ac_word... " >&6; }
10881 if ${ac_cv_path_SORT+:} false; then :
10882   $as_echo_n "(cached) " >&6
10883 else
10884   case $SORT in
10885   [\\/]* | ?:[\\/]*)
10886   ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
10887   ;;
10888   *)
10889   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10890 for as_dir in $PATH
10891 do
10892   IFS=$as_save_IFS
10893   test -z "$as_dir" && as_dir=.
10894     for ac_exec_ext in '' $ac_executable_extensions; do
10895   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10896     ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
10897     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10898     break 2
10899   fi
10900 done
10901   done
10902 IFS=$as_save_IFS
10903 
10904   ;;
10905 esac
10906 fi
10907 SORT=$ac_cv_path_SORT
10908 if test -n "$SORT"; then
10909   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
10910 $as_echo "$SORT" >&6; }
10911 else
10912   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10913 $as_echo "no" >&6; }
10914 fi
10915 
10916 
10917   test -n "$SORT" && break
10918 done
10919 
10920   else
10921     # The variable is set, but is it from the command line or the environment?
10922 
10923     # Try to remove the string !SORT! from our list.
10924     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SORT!/}
10925     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10926       # If it failed, the variable was not from the command line. Ignore it,
10927       # but warn the user (except for BASH, which is always set by the calling BASH).
10928       if test "xSORT" != xBASH; then
10929         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SORT from the environment. Use command line variables instead." >&5
10930 $as_echo "$as_me: WARNING: Ignoring value of SORT from the environment. Use command line variables instead." >&2;}
10931       fi
10932       # Try to locate tool using the code snippet
10933       for ac_prog in sort
10934 do
10935   # Extract the first word of "$ac_prog", so it can be a program name with args.
10936 set dummy $ac_prog; ac_word=$2
10937 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10938 $as_echo_n "checking for $ac_word... " >&6; }
10939 if ${ac_cv_path_SORT+:} false; then :
10940   $as_echo_n "(cached) " >&6
10941 else
10942   case $SORT in
10943   [\\/]* | ?:[\\/]*)
10944   ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
10945   ;;
10946   *)
10947   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10948 for as_dir in $PATH
10949 do
10950   IFS=$as_save_IFS
10951   test -z "$as_dir" && as_dir=.
10952     for ac_exec_ext in '' $ac_executable_extensions; do
10953   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10954     ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
10955     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10956     break 2
10957   fi
10958 done
10959   done
10960 IFS=$as_save_IFS
10961 
10962   ;;
10963 esac
10964 fi
10965 SORT=$ac_cv_path_SORT
10966 if test -n "$SORT"; then
10967   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
10968 $as_echo "$SORT" >&6; }
10969 else
10970   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10971 $as_echo "no" >&6; }
10972 fi
10973 
10974 
10975   test -n "$SORT" && break
10976 done
10977 
10978     else
10979       # If it succeeded, then it was overridden by the user. We will use it
10980       # for the tool.
10981 
10982       # First remove it from the list of overridden variables, so we can test
10983       # for unknown variables in the end.
10984       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10985 
10986       # Check if we try to supply an empty value
10987       if test "x$SORT" = x; then
10988         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool SORT= (no value)" >&5
10989 $as_echo "$as_me: Setting user supplied tool SORT= (no value)" >&6;}
10990         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SORT" >&5
10991 $as_echo_n "checking for SORT... " >&6; }
10992         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
10993 $as_echo "disabled" >&6; }
10994       else
10995         # Check if the provided tool contains a complete path.
10996         tool_specified="$SORT"
10997         tool_basename="${tool_specified##*/}"
10998         if test "x$tool_basename" = "x$tool_specified"; then
10999           # A command without a complete path is provided, search $PATH.
11000           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SORT=$tool_basename" >&5
11001 $as_echo "$as_me: Will search for user supplied tool SORT=$tool_basename" >&6;}
11002           # Extract the first word of "$tool_basename", so it can be a program name with args.
11003 set dummy $tool_basename; ac_word=$2
11004 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11005 $as_echo_n "checking for $ac_word... " >&6; }
11006 if ${ac_cv_path_SORT+:} false; then :
11007   $as_echo_n "(cached) " >&6
11008 else
11009   case $SORT in
11010   [\\/]* | ?:[\\/]*)
11011   ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
11012   ;;
11013   *)
11014   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11015 for as_dir in $PATH
11016 do
11017   IFS=$as_save_IFS
11018   test -z "$as_dir" && as_dir=.
11019     for ac_exec_ext in '' $ac_executable_extensions; do
11020   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11021     ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
11022     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11023     break 2
11024   fi
11025 done
11026   done
11027 IFS=$as_save_IFS
11028 
11029   ;;
11030 esac
11031 fi
11032 SORT=$ac_cv_path_SORT
11033 if test -n "$SORT"; then
11034   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
11035 $as_echo "$SORT" >&6; }
11036 else
11037   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11038 $as_echo "no" >&6; }
11039 fi
11040 
11041 
11042           if test "x$SORT" = x; then
11043             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11044           fi
11045         else
11046           # Otherwise we believe it is a complete path. Use it as it is.
11047           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SORT=$tool_specified" >&5
11048 $as_echo "$as_me: Will use user supplied tool SORT=$tool_specified" >&6;}
11049           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SORT" >&5
11050 $as_echo_n "checking for SORT... " >&6; }
11051           if test ! -x "$tool_specified"; then
11052             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11053 $as_echo "not found" >&6; }
11054             as_fn_error $? "User supplied tool SORT=$tool_specified does not exist or is not executable" "$LINENO" 5
11055           fi
11056           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11057 $as_echo "$tool_specified" >&6; }
11058         fi
11059       fi
11060     fi
11061 
11062   fi
11063 
11064 
11065 
11066   if test "x$SORT" = x; then
11067     as_fn_error $? "Could not find required tool for SORT" "$LINENO" 5
11068   fi
11069 
11070 
11071 
11072 
11073 
11074   # Publish this variable in the help.
11075 
11076 
11077   if [ -z "${TAIL+x}" ]; then
11078     # The variable is not set by user, try to locate tool using the code snippet
11079     for ac_prog in tail
11080 do
11081   # Extract the first word of "$ac_prog", so it can be a program name with args.
11082 set dummy $ac_prog; ac_word=$2
11083 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11084 $as_echo_n "checking for $ac_word... " >&6; }
11085 if ${ac_cv_path_TAIL+:} false; then :
11086   $as_echo_n "(cached) " >&6
11087 else
11088   case $TAIL in
11089   [\\/]* | ?:[\\/]*)
11090   ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
11091   ;;
11092   *)
11093   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11094 for as_dir in $PATH
11095 do
11096   IFS=$as_save_IFS
11097   test -z "$as_dir" && as_dir=.
11098     for ac_exec_ext in '' $ac_executable_extensions; do
11099   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11100     ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
11101     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11102     break 2
11103   fi
11104 done
11105   done
11106 IFS=$as_save_IFS
11107 
11108   ;;
11109 esac
11110 fi
11111 TAIL=$ac_cv_path_TAIL
11112 if test -n "$TAIL"; then
11113   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
11114 $as_echo "$TAIL" >&6; }
11115 else
11116   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11117 $as_echo "no" >&6; }
11118 fi
11119 
11120 
11121   test -n "$TAIL" && break
11122 done
11123 
11124   else
11125     # The variable is set, but is it from the command line or the environment?
11126 
11127     # Try to remove the string !TAIL! from our list.
11128     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TAIL!/}
11129     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11130       # If it failed, the variable was not from the command line. Ignore it,
11131       # but warn the user (except for BASH, which is always set by the calling BASH).
11132       if test "xTAIL" != xBASH; then
11133         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TAIL from the environment. Use command line variables instead." >&5
11134 $as_echo "$as_me: WARNING: Ignoring value of TAIL from the environment. Use command line variables instead." >&2;}
11135       fi
11136       # Try to locate tool using the code snippet
11137       for ac_prog in tail
11138 do
11139   # Extract the first word of "$ac_prog", so it can be a program name with args.
11140 set dummy $ac_prog; ac_word=$2
11141 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11142 $as_echo_n "checking for $ac_word... " >&6; }
11143 if ${ac_cv_path_TAIL+:} false; then :
11144   $as_echo_n "(cached) " >&6
11145 else
11146   case $TAIL in
11147   [\\/]* | ?:[\\/]*)
11148   ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
11149   ;;
11150   *)
11151   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11152 for as_dir in $PATH
11153 do
11154   IFS=$as_save_IFS
11155   test -z "$as_dir" && as_dir=.
11156     for ac_exec_ext in '' $ac_executable_extensions; do
11157   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11158     ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
11159     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11160     break 2
11161   fi
11162 done
11163   done
11164 IFS=$as_save_IFS
11165 
11166   ;;
11167 esac
11168 fi
11169 TAIL=$ac_cv_path_TAIL
11170 if test -n "$TAIL"; then
11171   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
11172 $as_echo "$TAIL" >&6; }
11173 else
11174   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11175 $as_echo "no" >&6; }
11176 fi
11177 
11178 
11179   test -n "$TAIL" && break
11180 done
11181 
11182     else
11183       # If it succeeded, then it was overridden by the user. We will use it
11184       # for the tool.
11185 
11186       # First remove it from the list of overridden variables, so we can test
11187       # for unknown variables in the end.
11188       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11189 
11190       # Check if we try to supply an empty value
11191       if test "x$TAIL" = x; then
11192         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool TAIL= (no value)" >&5
11193 $as_echo "$as_me: Setting user supplied tool TAIL= (no value)" >&6;}
11194         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAIL" >&5
11195 $as_echo_n "checking for TAIL... " >&6; }
11196         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
11197 $as_echo "disabled" >&6; }
11198       else
11199         # Check if the provided tool contains a complete path.
11200         tool_specified="$TAIL"
11201         tool_basename="${tool_specified##*/}"
11202         if test "x$tool_basename" = "x$tool_specified"; then
11203           # A command without a complete path is provided, search $PATH.
11204           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TAIL=$tool_basename" >&5
11205 $as_echo "$as_me: Will search for user supplied tool TAIL=$tool_basename" >&6;}
11206           # Extract the first word of "$tool_basename", so it can be a program name with args.
11207 set dummy $tool_basename; ac_word=$2
11208 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11209 $as_echo_n "checking for $ac_word... " >&6; }
11210 if ${ac_cv_path_TAIL+:} false; then :
11211   $as_echo_n "(cached) " >&6
11212 else
11213   case $TAIL in
11214   [\\/]* | ?:[\\/]*)
11215   ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
11216   ;;
11217   *)
11218   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11219 for as_dir in $PATH
11220 do
11221   IFS=$as_save_IFS
11222   test -z "$as_dir" && as_dir=.
11223     for ac_exec_ext in '' $ac_executable_extensions; do
11224   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11225     ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
11226     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11227     break 2
11228   fi
11229 done
11230   done
11231 IFS=$as_save_IFS
11232 
11233   ;;
11234 esac
11235 fi
11236 TAIL=$ac_cv_path_TAIL
11237 if test -n "$TAIL"; then
11238   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
11239 $as_echo "$TAIL" >&6; }
11240 else
11241   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11242 $as_echo "no" >&6; }
11243 fi
11244 
11245 
11246           if test "x$TAIL" = x; then
11247             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11248           fi
11249         else
11250           # Otherwise we believe it is a complete path. Use it as it is.
11251           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TAIL=$tool_specified" >&5
11252 $as_echo "$as_me: Will use user supplied tool TAIL=$tool_specified" >&6;}
11253           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAIL" >&5
11254 $as_echo_n "checking for TAIL... " >&6; }
11255           if test ! -x "$tool_specified"; then
11256             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11257 $as_echo "not found" >&6; }
11258             as_fn_error $? "User supplied tool TAIL=$tool_specified does not exist or is not executable" "$LINENO" 5
11259           fi
11260           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11261 $as_echo "$tool_specified" >&6; }
11262         fi
11263       fi
11264     fi
11265 
11266   fi
11267 
11268 
11269 
11270   if test "x$TAIL" = x; then
11271     as_fn_error $? "Could not find required tool for TAIL" "$LINENO" 5
11272   fi
11273 
11274 
11275 
11276 
11277 
11278   # Publish this variable in the help.
11279 
11280 
11281   if [ -z "${TAR+x}" ]; then
11282     # The variable is not set by user, try to locate tool using the code snippet
11283     for ac_prog in gtar tar
11284 do
11285   # Extract the first word of "$ac_prog", so it can be a program name with args.
11286 set dummy $ac_prog; ac_word=$2
11287 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11288 $as_echo_n "checking for $ac_word... " >&6; }
11289 if ${ac_cv_path_TAR+:} false; then :
11290   $as_echo_n "(cached) " >&6
11291 else
11292   case $TAR in
11293   [\\/]* | ?:[\\/]*)
11294   ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
11295   ;;
11296   *)
11297   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11298 for as_dir in $PATH
11299 do
11300   IFS=$as_save_IFS
11301   test -z "$as_dir" && as_dir=.
11302     for ac_exec_ext in '' $ac_executable_extensions; do
11303   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11304     ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
11305     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11306     break 2
11307   fi
11308 done
11309   done
11310 IFS=$as_save_IFS
11311 
11312   ;;
11313 esac
11314 fi
11315 TAR=$ac_cv_path_TAR
11316 if test -n "$TAR"; then
11317   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
11318 $as_echo "$TAR" >&6; }
11319 else
11320   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11321 $as_echo "no" >&6; }
11322 fi
11323 
11324 
11325   test -n "$TAR" && break
11326 done
11327 
11328   else
11329     # The variable is set, but is it from the command line or the environment?
11330 
11331     # Try to remove the string !TAR! from our list.
11332     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TAR!/}
11333     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11334       # If it failed, the variable was not from the command line. Ignore it,
11335       # but warn the user (except for BASH, which is always set by the calling BASH).
11336       if test "xTAR" != xBASH; then
11337         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TAR from the environment. Use command line variables instead." >&5
11338 $as_echo "$as_me: WARNING: Ignoring value of TAR from the environment. Use command line variables instead." >&2;}
11339       fi
11340       # Try to locate tool using the code snippet
11341       for ac_prog in gtar tar
11342 do
11343   # Extract the first word of "$ac_prog", so it can be a program name with args.
11344 set dummy $ac_prog; ac_word=$2
11345 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11346 $as_echo_n "checking for $ac_word... " >&6; }
11347 if ${ac_cv_path_TAR+:} false; then :
11348   $as_echo_n "(cached) " >&6
11349 else
11350   case $TAR in
11351   [\\/]* | ?:[\\/]*)
11352   ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
11353   ;;
11354   *)
11355   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11356 for as_dir in $PATH
11357 do
11358   IFS=$as_save_IFS
11359   test -z "$as_dir" && as_dir=.
11360     for ac_exec_ext in '' $ac_executable_extensions; do
11361   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11362     ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
11363     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11364     break 2
11365   fi
11366 done
11367   done
11368 IFS=$as_save_IFS
11369 
11370   ;;
11371 esac
11372 fi
11373 TAR=$ac_cv_path_TAR
11374 if test -n "$TAR"; then
11375   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
11376 $as_echo "$TAR" >&6; }
11377 else
11378   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11379 $as_echo "no" >&6; }
11380 fi
11381 
11382 
11383   test -n "$TAR" && break
11384 done
11385 
11386     else
11387       # If it succeeded, then it was overridden by the user. We will use it
11388       # for the tool.
11389 
11390       # First remove it from the list of overridden variables, so we can test
11391       # for unknown variables in the end.
11392       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11393 
11394       # Check if we try to supply an empty value
11395       if test "x$TAR" = x; then
11396         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool TAR= (no value)" >&5
11397 $as_echo "$as_me: Setting user supplied tool TAR= (no value)" >&6;}
11398         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAR" >&5
11399 $as_echo_n "checking for TAR... " >&6; }
11400         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
11401 $as_echo "disabled" >&6; }
11402       else
11403         # Check if the provided tool contains a complete path.
11404         tool_specified="$TAR"
11405         tool_basename="${tool_specified##*/}"
11406         if test "x$tool_basename" = "x$tool_specified"; then
11407           # A command without a complete path is provided, search $PATH.
11408           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TAR=$tool_basename" >&5
11409 $as_echo "$as_me: Will search for user supplied tool TAR=$tool_basename" >&6;}
11410           # Extract the first word of "$tool_basename", so it can be a program name with args.
11411 set dummy $tool_basename; ac_word=$2
11412 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11413 $as_echo_n "checking for $ac_word... " >&6; }
11414 if ${ac_cv_path_TAR+:} false; then :
11415   $as_echo_n "(cached) " >&6
11416 else
11417   case $TAR in
11418   [\\/]* | ?:[\\/]*)
11419   ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
11420   ;;
11421   *)
11422   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11423 for as_dir in $PATH
11424 do
11425   IFS=$as_save_IFS
11426   test -z "$as_dir" && as_dir=.
11427     for ac_exec_ext in '' $ac_executable_extensions; do
11428   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11429     ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
11430     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11431     break 2
11432   fi
11433 done
11434   done
11435 IFS=$as_save_IFS
11436 
11437   ;;
11438 esac
11439 fi
11440 TAR=$ac_cv_path_TAR
11441 if test -n "$TAR"; then
11442   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
11443 $as_echo "$TAR" >&6; }
11444 else
11445   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11446 $as_echo "no" >&6; }
11447 fi
11448 
11449 
11450           if test "x$TAR" = x; then
11451             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11452           fi
11453         else
11454           # Otherwise we believe it is a complete path. Use it as it is.
11455           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TAR=$tool_specified" >&5
11456 $as_echo "$as_me: Will use user supplied tool TAR=$tool_specified" >&6;}
11457           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAR" >&5
11458 $as_echo_n "checking for TAR... " >&6; }
11459           if test ! -x "$tool_specified"; then
11460             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11461 $as_echo "not found" >&6; }
11462             as_fn_error $? "User supplied tool TAR=$tool_specified does not exist or is not executable" "$LINENO" 5
11463           fi
11464           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11465 $as_echo "$tool_specified" >&6; }
11466         fi
11467       fi
11468     fi
11469 
11470   fi
11471 
11472 
11473 
11474   if test "x$TAR" = x; then
11475     as_fn_error $? "Could not find required tool for TAR" "$LINENO" 5
11476   fi
11477 
11478 
11479 
11480 
11481 
11482   # Publish this variable in the help.
11483 
11484 
11485   if [ -z "${TEE+x}" ]; then
11486     # The variable is not set by user, try to locate tool using the code snippet
11487     for ac_prog in tee
11488 do
11489   # Extract the first word of "$ac_prog", so it can be a program name with args.
11490 set dummy $ac_prog; ac_word=$2
11491 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11492 $as_echo_n "checking for $ac_word... " >&6; }
11493 if ${ac_cv_path_TEE+:} false; then :
11494   $as_echo_n "(cached) " >&6
11495 else
11496   case $TEE in
11497   [\\/]* | ?:[\\/]*)
11498   ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
11499   ;;
11500   *)
11501   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11502 for as_dir in $PATH
11503 do
11504   IFS=$as_save_IFS
11505   test -z "$as_dir" && as_dir=.
11506     for ac_exec_ext in '' $ac_executable_extensions; do
11507   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11508     ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
11509     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11510     break 2
11511   fi
11512 done
11513   done
11514 IFS=$as_save_IFS
11515 
11516   ;;
11517 esac
11518 fi
11519 TEE=$ac_cv_path_TEE
11520 if test -n "$TEE"; then
11521   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
11522 $as_echo "$TEE" >&6; }
11523 else
11524   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11525 $as_echo "no" >&6; }
11526 fi
11527 
11528 
11529   test -n "$TEE" && break
11530 done
11531 
11532   else
11533     # The variable is set, but is it from the command line or the environment?
11534 
11535     # Try to remove the string !TEE! from our list.
11536     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TEE!/}
11537     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11538       # If it failed, the variable was not from the command line. Ignore it,
11539       # but warn the user (except for BASH, which is always set by the calling BASH).
11540       if test "xTEE" != xBASH; then
11541         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TEE from the environment. Use command line variables instead." >&5
11542 $as_echo "$as_me: WARNING: Ignoring value of TEE from the environment. Use command line variables instead." >&2;}
11543       fi
11544       # Try to locate tool using the code snippet
11545       for ac_prog in tee
11546 do
11547   # Extract the first word of "$ac_prog", so it can be a program name with args.
11548 set dummy $ac_prog; ac_word=$2
11549 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11550 $as_echo_n "checking for $ac_word... " >&6; }
11551 if ${ac_cv_path_TEE+:} false; then :
11552   $as_echo_n "(cached) " >&6
11553 else
11554   case $TEE in
11555   [\\/]* | ?:[\\/]*)
11556   ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
11557   ;;
11558   *)
11559   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11560 for as_dir in $PATH
11561 do
11562   IFS=$as_save_IFS
11563   test -z "$as_dir" && as_dir=.
11564     for ac_exec_ext in '' $ac_executable_extensions; do
11565   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11566     ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
11567     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11568     break 2
11569   fi
11570 done
11571   done
11572 IFS=$as_save_IFS
11573 
11574   ;;
11575 esac
11576 fi
11577 TEE=$ac_cv_path_TEE
11578 if test -n "$TEE"; then
11579   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
11580 $as_echo "$TEE" >&6; }
11581 else
11582   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11583 $as_echo "no" >&6; }
11584 fi
11585 
11586 
11587   test -n "$TEE" && break
11588 done
11589 
11590     else
11591       # If it succeeded, then it was overridden by the user. We will use it
11592       # for the tool.
11593 
11594       # First remove it from the list of overridden variables, so we can test
11595       # for unknown variables in the end.
11596       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11597 
11598       # Check if we try to supply an empty value
11599       if test "x$TEE" = x; then
11600         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool TEE= (no value)" >&5
11601 $as_echo "$as_me: Setting user supplied tool TEE= (no value)" >&6;}
11602         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TEE" >&5
11603 $as_echo_n "checking for TEE... " >&6; }
11604         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
11605 $as_echo "disabled" >&6; }
11606       else
11607         # Check if the provided tool contains a complete path.
11608         tool_specified="$TEE"
11609         tool_basename="${tool_specified##*/}"
11610         if test "x$tool_basename" = "x$tool_specified"; then
11611           # A command without a complete path is provided, search $PATH.
11612           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TEE=$tool_basename" >&5
11613 $as_echo "$as_me: Will search for user supplied tool TEE=$tool_basename" >&6;}
11614           # Extract the first word of "$tool_basename", so it can be a program name with args.
11615 set dummy $tool_basename; ac_word=$2
11616 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11617 $as_echo_n "checking for $ac_word... " >&6; }
11618 if ${ac_cv_path_TEE+:} false; then :
11619   $as_echo_n "(cached) " >&6
11620 else
11621   case $TEE in
11622   [\\/]* | ?:[\\/]*)
11623   ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
11624   ;;
11625   *)
11626   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11627 for as_dir in $PATH
11628 do
11629   IFS=$as_save_IFS
11630   test -z "$as_dir" && as_dir=.
11631     for ac_exec_ext in '' $ac_executable_extensions; do
11632   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11633     ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
11634     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11635     break 2
11636   fi
11637 done
11638   done
11639 IFS=$as_save_IFS
11640 
11641   ;;
11642 esac
11643 fi
11644 TEE=$ac_cv_path_TEE
11645 if test -n "$TEE"; then
11646   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
11647 $as_echo "$TEE" >&6; }
11648 else
11649   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11650 $as_echo "no" >&6; }
11651 fi
11652 
11653 
11654           if test "x$TEE" = x; then
11655             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11656           fi
11657         else
11658           # Otherwise we believe it is a complete path. Use it as it is.
11659           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TEE=$tool_specified" >&5
11660 $as_echo "$as_me: Will use user supplied tool TEE=$tool_specified" >&6;}
11661           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TEE" >&5
11662 $as_echo_n "checking for TEE... " >&6; }
11663           if test ! -x "$tool_specified"; then
11664             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11665 $as_echo "not found" >&6; }
11666             as_fn_error $? "User supplied tool TEE=$tool_specified does not exist or is not executable" "$LINENO" 5
11667           fi
11668           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11669 $as_echo "$tool_specified" >&6; }
11670         fi
11671       fi
11672     fi
11673 
11674   fi
11675 
11676 
11677 
11678   if test "x$TEE" = x; then
11679     as_fn_error $? "Could not find required tool for TEE" "$LINENO" 5
11680   fi
11681 
11682 
11683 
11684 
11685 
11686   # Publish this variable in the help.
11687 
11688 
11689   if [ -z "${TOUCH+x}" ]; then
11690     # The variable is not set by user, try to locate tool using the code snippet
11691     for ac_prog in touch
11692 do
11693   # Extract the first word of "$ac_prog", so it can be a program name with args.
11694 set dummy $ac_prog; ac_word=$2
11695 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11696 $as_echo_n "checking for $ac_word... " >&6; }
11697 if ${ac_cv_path_TOUCH+:} false; then :
11698   $as_echo_n "(cached) " >&6
11699 else
11700   case $TOUCH in
11701   [\\/]* | ?:[\\/]*)
11702   ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
11703   ;;
11704   *)
11705   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11706 for as_dir in $PATH
11707 do
11708   IFS=$as_save_IFS
11709   test -z "$as_dir" && as_dir=.
11710     for ac_exec_ext in '' $ac_executable_extensions; do
11711   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11712     ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
11713     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11714     break 2
11715   fi
11716 done
11717   done
11718 IFS=$as_save_IFS
11719 
11720   ;;
11721 esac
11722 fi
11723 TOUCH=$ac_cv_path_TOUCH
11724 if test -n "$TOUCH"; then
11725   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
11726 $as_echo "$TOUCH" >&6; }
11727 else
11728   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11729 $as_echo "no" >&6; }
11730 fi
11731 
11732 
11733   test -n "$TOUCH" && break
11734 done
11735 
11736   else
11737     # The variable is set, but is it from the command line or the environment?
11738 
11739     # Try to remove the string !TOUCH! from our list.
11740     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TOUCH!/}
11741     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11742       # If it failed, the variable was not from the command line. Ignore it,
11743       # but warn the user (except for BASH, which is always set by the calling BASH).
11744       if test "xTOUCH" != xBASH; then
11745         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TOUCH from the environment. Use command line variables instead." >&5
11746 $as_echo "$as_me: WARNING: Ignoring value of TOUCH from the environment. Use command line variables instead." >&2;}
11747       fi
11748       # Try to locate tool using the code snippet
11749       for ac_prog in touch
11750 do
11751   # Extract the first word of "$ac_prog", so it can be a program name with args.
11752 set dummy $ac_prog; ac_word=$2
11753 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11754 $as_echo_n "checking for $ac_word... " >&6; }
11755 if ${ac_cv_path_TOUCH+:} false; then :
11756   $as_echo_n "(cached) " >&6
11757 else
11758   case $TOUCH in
11759   [\\/]* | ?:[\\/]*)
11760   ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
11761   ;;
11762   *)
11763   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11764 for as_dir in $PATH
11765 do
11766   IFS=$as_save_IFS
11767   test -z "$as_dir" && as_dir=.
11768     for ac_exec_ext in '' $ac_executable_extensions; do
11769   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11770     ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
11771     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11772     break 2
11773   fi
11774 done
11775   done
11776 IFS=$as_save_IFS
11777 
11778   ;;
11779 esac
11780 fi
11781 TOUCH=$ac_cv_path_TOUCH
11782 if test -n "$TOUCH"; then
11783   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
11784 $as_echo "$TOUCH" >&6; }
11785 else
11786   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11787 $as_echo "no" >&6; }
11788 fi
11789 
11790 
11791   test -n "$TOUCH" && break
11792 done
11793 
11794     else
11795       # If it succeeded, then it was overridden by the user. We will use it
11796       # for the tool.
11797 
11798       # First remove it from the list of overridden variables, so we can test
11799       # for unknown variables in the end.
11800       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11801 
11802       # Check if we try to supply an empty value
11803       if test "x$TOUCH" = x; then
11804         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool TOUCH= (no value)" >&5
11805 $as_echo "$as_me: Setting user supplied tool TOUCH= (no value)" >&6;}
11806         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TOUCH" >&5
11807 $as_echo_n "checking for TOUCH... " >&6; }
11808         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
11809 $as_echo "disabled" >&6; }
11810       else
11811         # Check if the provided tool contains a complete path.
11812         tool_specified="$TOUCH"
11813         tool_basename="${tool_specified##*/}"
11814         if test "x$tool_basename" = "x$tool_specified"; then
11815           # A command without a complete path is provided, search $PATH.
11816           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TOUCH=$tool_basename" >&5
11817 $as_echo "$as_me: Will search for user supplied tool TOUCH=$tool_basename" >&6;}
11818           # Extract the first word of "$tool_basename", so it can be a program name with args.
11819 set dummy $tool_basename; ac_word=$2
11820 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11821 $as_echo_n "checking for $ac_word... " >&6; }
11822 if ${ac_cv_path_TOUCH+:} false; then :
11823   $as_echo_n "(cached) " >&6
11824 else
11825   case $TOUCH in
11826   [\\/]* | ?:[\\/]*)
11827   ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
11828   ;;
11829   *)
11830   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11831 for as_dir in $PATH
11832 do
11833   IFS=$as_save_IFS
11834   test -z "$as_dir" && as_dir=.
11835     for ac_exec_ext in '' $ac_executable_extensions; do
11836   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11837     ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
11838     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11839     break 2
11840   fi
11841 done
11842   done
11843 IFS=$as_save_IFS
11844 
11845   ;;
11846 esac
11847 fi
11848 TOUCH=$ac_cv_path_TOUCH
11849 if test -n "$TOUCH"; then
11850   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
11851 $as_echo "$TOUCH" >&6; }
11852 else
11853   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11854 $as_echo "no" >&6; }
11855 fi
11856 
11857 
11858           if test "x$TOUCH" = x; then
11859             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11860           fi
11861         else
11862           # Otherwise we believe it is a complete path. Use it as it is.
11863           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TOUCH=$tool_specified" >&5
11864 $as_echo "$as_me: Will use user supplied tool TOUCH=$tool_specified" >&6;}
11865           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TOUCH" >&5
11866 $as_echo_n "checking for TOUCH... " >&6; }
11867           if test ! -x "$tool_specified"; then
11868             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11869 $as_echo "not found" >&6; }
11870             as_fn_error $? "User supplied tool TOUCH=$tool_specified does not exist or is not executable" "$LINENO" 5
11871           fi
11872           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11873 $as_echo "$tool_specified" >&6; }
11874         fi
11875       fi
11876     fi
11877 
11878   fi
11879 
11880 
11881 
11882   if test "x$TOUCH" = x; then
11883     as_fn_error $? "Could not find required tool for TOUCH" "$LINENO" 5
11884   fi
11885 
11886 
11887 
11888 
11889 
11890   # Publish this variable in the help.
11891 
11892 
11893   if [ -z "${TR+x}" ]; then
11894     # The variable is not set by user, try to locate tool using the code snippet
11895     for ac_prog in tr
11896 do
11897   # Extract the first word of "$ac_prog", so it can be a program name with args.
11898 set dummy $ac_prog; ac_word=$2
11899 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11900 $as_echo_n "checking for $ac_word... " >&6; }
11901 if ${ac_cv_path_TR+:} false; then :
11902   $as_echo_n "(cached) " >&6
11903 else
11904   case $TR in
11905   [\\/]* | ?:[\\/]*)
11906   ac_cv_path_TR="$TR" # Let the user override the test with a path.
11907   ;;
11908   *)
11909   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11910 for as_dir in $PATH
11911 do
11912   IFS=$as_save_IFS
11913   test -z "$as_dir" && as_dir=.
11914     for ac_exec_ext in '' $ac_executable_extensions; do
11915   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11916     ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
11917     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11918     break 2
11919   fi
11920 done
11921   done
11922 IFS=$as_save_IFS
11923 
11924   ;;
11925 esac
11926 fi
11927 TR=$ac_cv_path_TR
11928 if test -n "$TR"; then
11929   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
11930 $as_echo "$TR" >&6; }
11931 else
11932   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11933 $as_echo "no" >&6; }
11934 fi
11935 
11936 
11937   test -n "$TR" && break
11938 done
11939 
11940   else
11941     # The variable is set, but is it from the command line or the environment?
11942 
11943     # Try to remove the string !TR! from our list.
11944     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TR!/}
11945     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11946       # If it failed, the variable was not from the command line. Ignore it,
11947       # but warn the user (except for BASH, which is always set by the calling BASH).
11948       if test "xTR" != xBASH; then
11949         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TR from the environment. Use command line variables instead." >&5
11950 $as_echo "$as_me: WARNING: Ignoring value of TR from the environment. Use command line variables instead." >&2;}
11951       fi
11952       # Try to locate tool using the code snippet
11953       for ac_prog in tr
11954 do
11955   # Extract the first word of "$ac_prog", so it can be a program name with args.
11956 set dummy $ac_prog; ac_word=$2
11957 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11958 $as_echo_n "checking for $ac_word... " >&6; }
11959 if ${ac_cv_path_TR+:} false; then :
11960   $as_echo_n "(cached) " >&6
11961 else
11962   case $TR in
11963   [\\/]* | ?:[\\/]*)
11964   ac_cv_path_TR="$TR" # Let the user override the test with a path.
11965   ;;
11966   *)
11967   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11968 for as_dir in $PATH
11969 do
11970   IFS=$as_save_IFS
11971   test -z "$as_dir" && as_dir=.
11972     for ac_exec_ext in '' $ac_executable_extensions; do
11973   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11974     ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
11975     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11976     break 2
11977   fi
11978 done
11979   done
11980 IFS=$as_save_IFS
11981 
11982   ;;
11983 esac
11984 fi
11985 TR=$ac_cv_path_TR
11986 if test -n "$TR"; then
11987   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
11988 $as_echo "$TR" >&6; }
11989 else
11990   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11991 $as_echo "no" >&6; }
11992 fi
11993 
11994 
11995   test -n "$TR" && break
11996 done
11997 
11998     else
11999       # If it succeeded, then it was overridden by the user. We will use it
12000       # for the tool.
12001 
12002       # First remove it from the list of overridden variables, so we can test
12003       # for unknown variables in the end.
12004       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12005 
12006       # Check if we try to supply an empty value
12007       if test "x$TR" = x; then
12008         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool TR= (no value)" >&5
12009 $as_echo "$as_me: Setting user supplied tool TR= (no value)" >&6;}
12010         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TR" >&5
12011 $as_echo_n "checking for TR... " >&6; }
12012         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
12013 $as_echo "disabled" >&6; }
12014       else
12015         # Check if the provided tool contains a complete path.
12016         tool_specified="$TR"
12017         tool_basename="${tool_specified##*/}"
12018         if test "x$tool_basename" = "x$tool_specified"; then
12019           # A command without a complete path is provided, search $PATH.
12020           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TR=$tool_basename" >&5
12021 $as_echo "$as_me: Will search for user supplied tool TR=$tool_basename" >&6;}
12022           # Extract the first word of "$tool_basename", so it can be a program name with args.
12023 set dummy $tool_basename; ac_word=$2
12024 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12025 $as_echo_n "checking for $ac_word... " >&6; }
12026 if ${ac_cv_path_TR+:} false; then :
12027   $as_echo_n "(cached) " >&6
12028 else
12029   case $TR in
12030   [\\/]* | ?:[\\/]*)
12031   ac_cv_path_TR="$TR" # Let the user override the test with a path.
12032   ;;
12033   *)
12034   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12035 for as_dir in $PATH
12036 do
12037   IFS=$as_save_IFS
12038   test -z "$as_dir" && as_dir=.
12039     for ac_exec_ext in '' $ac_executable_extensions; do
12040   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12041     ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
12042     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12043     break 2
12044   fi
12045 done
12046   done
12047 IFS=$as_save_IFS
12048 
12049   ;;
12050 esac
12051 fi
12052 TR=$ac_cv_path_TR
12053 if test -n "$TR"; then
12054   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
12055 $as_echo "$TR" >&6; }
12056 else
12057   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12058 $as_echo "no" >&6; }
12059 fi
12060 
12061 
12062           if test "x$TR" = x; then
12063             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12064           fi
12065         else
12066           # Otherwise we believe it is a complete path. Use it as it is.
12067           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TR=$tool_specified" >&5
12068 $as_echo "$as_me: Will use user supplied tool TR=$tool_specified" >&6;}
12069           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TR" >&5
12070 $as_echo_n "checking for TR... " >&6; }
12071           if test ! -x "$tool_specified"; then
12072             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12073 $as_echo "not found" >&6; }
12074             as_fn_error $? "User supplied tool TR=$tool_specified does not exist or is not executable" "$LINENO" 5
12075           fi
12076           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12077 $as_echo "$tool_specified" >&6; }
12078         fi
12079       fi
12080     fi
12081 
12082   fi
12083 
12084 
12085 
12086   if test "x$TR" = x; then
12087     as_fn_error $? "Could not find required tool for TR" "$LINENO" 5
12088   fi
12089 
12090 
12091 
12092 
12093 
12094   # Publish this variable in the help.
12095 
12096 
12097   if [ -z "${UNAME+x}" ]; then
12098     # The variable is not set by user, try to locate tool using the code snippet
12099     for ac_prog in uname
12100 do
12101   # Extract the first word of "$ac_prog", so it can be a program name with args.
12102 set dummy $ac_prog; ac_word=$2
12103 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12104 $as_echo_n "checking for $ac_word... " >&6; }
12105 if ${ac_cv_path_UNAME+:} false; then :
12106   $as_echo_n "(cached) " >&6
12107 else
12108   case $UNAME in
12109   [\\/]* | ?:[\\/]*)
12110   ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
12111   ;;
12112   *)
12113   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12114 for as_dir in $PATH
12115 do
12116   IFS=$as_save_IFS
12117   test -z "$as_dir" && as_dir=.
12118     for ac_exec_ext in '' $ac_executable_extensions; do
12119   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12120     ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
12121     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12122     break 2
12123   fi
12124 done
12125   done
12126 IFS=$as_save_IFS
12127 
12128   ;;
12129 esac
12130 fi
12131 UNAME=$ac_cv_path_UNAME
12132 if test -n "$UNAME"; then
12133   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
12134 $as_echo "$UNAME" >&6; }
12135 else
12136   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12137 $as_echo "no" >&6; }
12138 fi
12139 
12140 
12141   test -n "$UNAME" && break
12142 done
12143 
12144   else
12145     # The variable is set, but is it from the command line or the environment?
12146 
12147     # Try to remove the string !UNAME! from our list.
12148     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNAME!/}
12149     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12150       # If it failed, the variable was not from the command line. Ignore it,
12151       # but warn the user (except for BASH, which is always set by the calling BASH).
12152       if test "xUNAME" != xBASH; then
12153         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNAME from the environment. Use command line variables instead." >&5
12154 $as_echo "$as_me: WARNING: Ignoring value of UNAME from the environment. Use command line variables instead." >&2;}
12155       fi
12156       # Try to locate tool using the code snippet
12157       for ac_prog in uname
12158 do
12159   # Extract the first word of "$ac_prog", so it can be a program name with args.
12160 set dummy $ac_prog; ac_word=$2
12161 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12162 $as_echo_n "checking for $ac_word... " >&6; }
12163 if ${ac_cv_path_UNAME+:} false; then :
12164   $as_echo_n "(cached) " >&6
12165 else
12166   case $UNAME in
12167   [\\/]* | ?:[\\/]*)
12168   ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
12169   ;;
12170   *)
12171   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12172 for as_dir in $PATH
12173 do
12174   IFS=$as_save_IFS
12175   test -z "$as_dir" && as_dir=.
12176     for ac_exec_ext in '' $ac_executable_extensions; do
12177   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12178     ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
12179     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12180     break 2
12181   fi
12182 done
12183   done
12184 IFS=$as_save_IFS
12185 
12186   ;;
12187 esac
12188 fi
12189 UNAME=$ac_cv_path_UNAME
12190 if test -n "$UNAME"; then
12191   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
12192 $as_echo "$UNAME" >&6; }
12193 else
12194   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12195 $as_echo "no" >&6; }
12196 fi
12197 
12198 
12199   test -n "$UNAME" && break
12200 done
12201 
12202     else
12203       # If it succeeded, then it was overridden by the user. We will use it
12204       # for the tool.
12205 
12206       # First remove it from the list of overridden variables, so we can test
12207       # for unknown variables in the end.
12208       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12209 
12210       # Check if we try to supply an empty value
12211       if test "x$UNAME" = x; then
12212         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool UNAME= (no value)" >&5
12213 $as_echo "$as_me: Setting user supplied tool UNAME= (no value)" >&6;}
12214         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNAME" >&5
12215 $as_echo_n "checking for UNAME... " >&6; }
12216         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
12217 $as_echo "disabled" >&6; }
12218       else
12219         # Check if the provided tool contains a complete path.
12220         tool_specified="$UNAME"
12221         tool_basename="${tool_specified##*/}"
12222         if test "x$tool_basename" = "x$tool_specified"; then
12223           # A command without a complete path is provided, search $PATH.
12224           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNAME=$tool_basename" >&5
12225 $as_echo "$as_me: Will search for user supplied tool UNAME=$tool_basename" >&6;}
12226           # Extract the first word of "$tool_basename", so it can be a program name with args.
12227 set dummy $tool_basename; ac_word=$2
12228 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12229 $as_echo_n "checking for $ac_word... " >&6; }
12230 if ${ac_cv_path_UNAME+:} false; then :
12231   $as_echo_n "(cached) " >&6
12232 else
12233   case $UNAME in
12234   [\\/]* | ?:[\\/]*)
12235   ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
12236   ;;
12237   *)
12238   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12239 for as_dir in $PATH
12240 do
12241   IFS=$as_save_IFS
12242   test -z "$as_dir" && as_dir=.
12243     for ac_exec_ext in '' $ac_executable_extensions; do
12244   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12245     ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
12246     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12247     break 2
12248   fi
12249 done
12250   done
12251 IFS=$as_save_IFS
12252 
12253   ;;
12254 esac
12255 fi
12256 UNAME=$ac_cv_path_UNAME
12257 if test -n "$UNAME"; then
12258   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
12259 $as_echo "$UNAME" >&6; }
12260 else
12261   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12262 $as_echo "no" >&6; }
12263 fi
12264 
12265 
12266           if test "x$UNAME" = x; then
12267             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12268           fi
12269         else
12270           # Otherwise we believe it is a complete path. Use it as it is.
12271           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNAME=$tool_specified" >&5
12272 $as_echo "$as_me: Will use user supplied tool UNAME=$tool_specified" >&6;}
12273           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNAME" >&5
12274 $as_echo_n "checking for UNAME... " >&6; }
12275           if test ! -x "$tool_specified"; then
12276             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12277 $as_echo "not found" >&6; }
12278             as_fn_error $? "User supplied tool UNAME=$tool_specified does not exist or is not executable" "$LINENO" 5
12279           fi
12280           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12281 $as_echo "$tool_specified" >&6; }
12282         fi
12283       fi
12284     fi
12285 
12286   fi
12287 
12288 
12289 
12290   if test "x$UNAME" = x; then
12291     as_fn_error $? "Could not find required tool for UNAME" "$LINENO" 5
12292   fi
12293 
12294 
12295 
12296 
12297 
12298   # Publish this variable in the help.
12299 
12300 
12301   if [ -z "${UNIQ+x}" ]; then
12302     # The variable is not set by user, try to locate tool using the code snippet
12303     for ac_prog in uniq
12304 do
12305   # Extract the first word of "$ac_prog", so it can be a program name with args.
12306 set dummy $ac_prog; ac_word=$2
12307 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12308 $as_echo_n "checking for $ac_word... " >&6; }
12309 if ${ac_cv_path_UNIQ+:} false; then :
12310   $as_echo_n "(cached) " >&6
12311 else
12312   case $UNIQ in
12313   [\\/]* | ?:[\\/]*)
12314   ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
12315   ;;
12316   *)
12317   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12318 for as_dir in $PATH
12319 do
12320   IFS=$as_save_IFS
12321   test -z "$as_dir" && as_dir=.
12322     for ac_exec_ext in '' $ac_executable_extensions; do
12323   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12324     ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
12325     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12326     break 2
12327   fi
12328 done
12329   done
12330 IFS=$as_save_IFS
12331 
12332   ;;
12333 esac
12334 fi
12335 UNIQ=$ac_cv_path_UNIQ
12336 if test -n "$UNIQ"; then
12337   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
12338 $as_echo "$UNIQ" >&6; }
12339 else
12340   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12341 $as_echo "no" >&6; }
12342 fi
12343 
12344 
12345   test -n "$UNIQ" && break
12346 done
12347 
12348   else
12349     # The variable is set, but is it from the command line or the environment?
12350 
12351     # Try to remove the string !UNIQ! from our list.
12352     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNIQ!/}
12353     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12354       # If it failed, the variable was not from the command line. Ignore it,
12355       # but warn the user (except for BASH, which is always set by the calling BASH).
12356       if test "xUNIQ" != xBASH; then
12357         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNIQ from the environment. Use command line variables instead." >&5
12358 $as_echo "$as_me: WARNING: Ignoring value of UNIQ from the environment. Use command line variables instead." >&2;}
12359       fi
12360       # Try to locate tool using the code snippet
12361       for ac_prog in uniq
12362 do
12363   # Extract the first word of "$ac_prog", so it can be a program name with args.
12364 set dummy $ac_prog; ac_word=$2
12365 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12366 $as_echo_n "checking for $ac_word... " >&6; }
12367 if ${ac_cv_path_UNIQ+:} false; then :
12368   $as_echo_n "(cached) " >&6
12369 else
12370   case $UNIQ in
12371   [\\/]* | ?:[\\/]*)
12372   ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
12373   ;;
12374   *)
12375   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12376 for as_dir in $PATH
12377 do
12378   IFS=$as_save_IFS
12379   test -z "$as_dir" && as_dir=.
12380     for ac_exec_ext in '' $ac_executable_extensions; do
12381   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12382     ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
12383     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12384     break 2
12385   fi
12386 done
12387   done
12388 IFS=$as_save_IFS
12389 
12390   ;;
12391 esac
12392 fi
12393 UNIQ=$ac_cv_path_UNIQ
12394 if test -n "$UNIQ"; then
12395   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
12396 $as_echo "$UNIQ" >&6; }
12397 else
12398   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12399 $as_echo "no" >&6; }
12400 fi
12401 
12402 
12403   test -n "$UNIQ" && break
12404 done
12405 
12406     else
12407       # If it succeeded, then it was overridden by the user. We will use it
12408       # for the tool.
12409 
12410       # First remove it from the list of overridden variables, so we can test
12411       # for unknown variables in the end.
12412       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12413 
12414       # Check if we try to supply an empty value
12415       if test "x$UNIQ" = x; then
12416         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool UNIQ= (no value)" >&5
12417 $as_echo "$as_me: Setting user supplied tool UNIQ= (no value)" >&6;}
12418         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNIQ" >&5
12419 $as_echo_n "checking for UNIQ... " >&6; }
12420         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
12421 $as_echo "disabled" >&6; }
12422       else
12423         # Check if the provided tool contains a complete path.
12424         tool_specified="$UNIQ"
12425         tool_basename="${tool_specified##*/}"
12426         if test "x$tool_basename" = "x$tool_specified"; then
12427           # A command without a complete path is provided, search $PATH.
12428           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNIQ=$tool_basename" >&5
12429 $as_echo "$as_me: Will search for user supplied tool UNIQ=$tool_basename" >&6;}
12430           # Extract the first word of "$tool_basename", so it can be a program name with args.
12431 set dummy $tool_basename; ac_word=$2
12432 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12433 $as_echo_n "checking for $ac_word... " >&6; }
12434 if ${ac_cv_path_UNIQ+:} false; then :
12435   $as_echo_n "(cached) " >&6
12436 else
12437   case $UNIQ in
12438   [\\/]* | ?:[\\/]*)
12439   ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
12440   ;;
12441   *)
12442   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12443 for as_dir in $PATH
12444 do
12445   IFS=$as_save_IFS
12446   test -z "$as_dir" && as_dir=.
12447     for ac_exec_ext in '' $ac_executable_extensions; do
12448   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12449     ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
12450     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12451     break 2
12452   fi
12453 done
12454   done
12455 IFS=$as_save_IFS
12456 
12457   ;;
12458 esac
12459 fi
12460 UNIQ=$ac_cv_path_UNIQ
12461 if test -n "$UNIQ"; then
12462   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
12463 $as_echo "$UNIQ" >&6; }
12464 else
12465   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12466 $as_echo "no" >&6; }
12467 fi
12468 
12469 
12470           if test "x$UNIQ" = x; then
12471             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12472           fi
12473         else
12474           # Otherwise we believe it is a complete path. Use it as it is.
12475           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNIQ=$tool_specified" >&5
12476 $as_echo "$as_me: Will use user supplied tool UNIQ=$tool_specified" >&6;}
12477           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNIQ" >&5
12478 $as_echo_n "checking for UNIQ... " >&6; }
12479           if test ! -x "$tool_specified"; then
12480             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12481 $as_echo "not found" >&6; }
12482             as_fn_error $? "User supplied tool UNIQ=$tool_specified does not exist or is not executable" "$LINENO" 5
12483           fi
12484           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12485 $as_echo "$tool_specified" >&6; }
12486         fi
12487       fi
12488     fi
12489 
12490   fi
12491 
12492 
12493 
12494   if test "x$UNIQ" = x; then
12495     as_fn_error $? "Could not find required tool for UNIQ" "$LINENO" 5
12496   fi
12497 
12498 
12499 
12500 
12501 
12502   # Publish this variable in the help.
12503 
12504 
12505   if [ -z "${WC+x}" ]; then
12506     # The variable is not set by user, try to locate tool using the code snippet
12507     for ac_prog in wc
12508 do
12509   # Extract the first word of "$ac_prog", so it can be a program name with args.
12510 set dummy $ac_prog; ac_word=$2
12511 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12512 $as_echo_n "checking for $ac_word... " >&6; }
12513 if ${ac_cv_path_WC+:} false; then :
12514   $as_echo_n "(cached) " >&6
12515 else
12516   case $WC in
12517   [\\/]* | ?:[\\/]*)
12518   ac_cv_path_WC="$WC" # Let the user override the test with a path.
12519   ;;
12520   *)
12521   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12522 for as_dir in $PATH
12523 do
12524   IFS=$as_save_IFS
12525   test -z "$as_dir" && as_dir=.
12526     for ac_exec_ext in '' $ac_executable_extensions; do
12527   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12528     ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
12529     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12530     break 2
12531   fi
12532 done
12533   done
12534 IFS=$as_save_IFS
12535 
12536   ;;
12537 esac
12538 fi
12539 WC=$ac_cv_path_WC
12540 if test -n "$WC"; then
12541   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
12542 $as_echo "$WC" >&6; }
12543 else
12544   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12545 $as_echo "no" >&6; }
12546 fi
12547 
12548 
12549   test -n "$WC" && break
12550 done
12551 
12552   else
12553     # The variable is set, but is it from the command line or the environment?
12554 
12555     # Try to remove the string !WC! from our list.
12556     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!WC!/}
12557     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12558       # If it failed, the variable was not from the command line. Ignore it,
12559       # but warn the user (except for BASH, which is always set by the calling BASH).
12560       if test "xWC" != xBASH; then
12561         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of WC from the environment. Use command line variables instead." >&5
12562 $as_echo "$as_me: WARNING: Ignoring value of WC from the environment. Use command line variables instead." >&2;}
12563       fi
12564       # Try to locate tool using the code snippet
12565       for ac_prog in wc
12566 do
12567   # Extract the first word of "$ac_prog", so it can be a program name with args.
12568 set dummy $ac_prog; ac_word=$2
12569 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12570 $as_echo_n "checking for $ac_word... " >&6; }
12571 if ${ac_cv_path_WC+:} false; then :
12572   $as_echo_n "(cached) " >&6
12573 else
12574   case $WC in
12575   [\\/]* | ?:[\\/]*)
12576   ac_cv_path_WC="$WC" # Let the user override the test with a path.
12577   ;;
12578   *)
12579   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12580 for as_dir in $PATH
12581 do
12582   IFS=$as_save_IFS
12583   test -z "$as_dir" && as_dir=.
12584     for ac_exec_ext in '' $ac_executable_extensions; do
12585   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12586     ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
12587     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12588     break 2
12589   fi
12590 done
12591   done
12592 IFS=$as_save_IFS
12593 
12594   ;;
12595 esac
12596 fi
12597 WC=$ac_cv_path_WC
12598 if test -n "$WC"; then
12599   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
12600 $as_echo "$WC" >&6; }
12601 else
12602   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12603 $as_echo "no" >&6; }
12604 fi
12605 
12606 
12607   test -n "$WC" && break
12608 done
12609 
12610     else
12611       # If it succeeded, then it was overridden by the user. We will use it
12612       # for the tool.
12613 
12614       # First remove it from the list of overridden variables, so we can test
12615       # for unknown variables in the end.
12616       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12617 
12618       # Check if we try to supply an empty value
12619       if test "x$WC" = x; then
12620         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool WC= (no value)" >&5
12621 $as_echo "$as_me: Setting user supplied tool WC= (no value)" >&6;}
12622         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WC" >&5
12623 $as_echo_n "checking for WC... " >&6; }
12624         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
12625 $as_echo "disabled" >&6; }
12626       else
12627         # Check if the provided tool contains a complete path.
12628         tool_specified="$WC"
12629         tool_basename="${tool_specified##*/}"
12630         if test "x$tool_basename" = "x$tool_specified"; then
12631           # A command without a complete path is provided, search $PATH.
12632           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool WC=$tool_basename" >&5
12633 $as_echo "$as_me: Will search for user supplied tool WC=$tool_basename" >&6;}
12634           # Extract the first word of "$tool_basename", so it can be a program name with args.
12635 set dummy $tool_basename; ac_word=$2
12636 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12637 $as_echo_n "checking for $ac_word... " >&6; }
12638 if ${ac_cv_path_WC+:} false; then :
12639   $as_echo_n "(cached) " >&6
12640 else
12641   case $WC in
12642   [\\/]* | ?:[\\/]*)
12643   ac_cv_path_WC="$WC" # Let the user override the test with a path.
12644   ;;
12645   *)
12646   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12647 for as_dir in $PATH
12648 do
12649   IFS=$as_save_IFS
12650   test -z "$as_dir" && as_dir=.
12651     for ac_exec_ext in '' $ac_executable_extensions; do
12652   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12653     ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
12654     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12655     break 2
12656   fi
12657 done
12658   done
12659 IFS=$as_save_IFS
12660 
12661   ;;
12662 esac
12663 fi
12664 WC=$ac_cv_path_WC
12665 if test -n "$WC"; then
12666   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
12667 $as_echo "$WC" >&6; }
12668 else
12669   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12670 $as_echo "no" >&6; }
12671 fi
12672 
12673 
12674           if test "x$WC" = x; then
12675             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12676           fi
12677         else
12678           # Otherwise we believe it is a complete path. Use it as it is.
12679           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool WC=$tool_specified" >&5
12680 $as_echo "$as_me: Will use user supplied tool WC=$tool_specified" >&6;}
12681           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WC" >&5
12682 $as_echo_n "checking for WC... " >&6; }
12683           if test ! -x "$tool_specified"; then
12684             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12685 $as_echo "not found" >&6; }
12686             as_fn_error $? "User supplied tool WC=$tool_specified does not exist or is not executable" "$LINENO" 5
12687           fi
12688           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12689 $as_echo "$tool_specified" >&6; }
12690         fi
12691       fi
12692     fi
12693 
12694   fi
12695 
12696 
12697 
12698   if test "x$WC" = x; then
12699     as_fn_error $? "Could not find required tool for WC" "$LINENO" 5
12700   fi
12701 
12702 
12703 
12704 
12705 
12706   # Publish this variable in the help.
12707 
12708 
12709   if [ -z "${WHICH+x}" ]; then
12710     # The variable is not set by user, try to locate tool using the code snippet
12711     for ac_prog in which
12712 do
12713   # Extract the first word of "$ac_prog", so it can be a program name with args.
12714 set dummy $ac_prog; ac_word=$2
12715 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12716 $as_echo_n "checking for $ac_word... " >&6; }
12717 if ${ac_cv_path_WHICH+:} false; then :
12718   $as_echo_n "(cached) " >&6
12719 else
12720   case $WHICH in
12721   [\\/]* | ?:[\\/]*)
12722   ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
12723   ;;
12724   *)
12725   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12726 for as_dir in $PATH
12727 do
12728   IFS=$as_save_IFS
12729   test -z "$as_dir" && as_dir=.
12730     for ac_exec_ext in '' $ac_executable_extensions; do
12731   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12732     ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
12733     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12734     break 2
12735   fi
12736 done
12737   done
12738 IFS=$as_save_IFS
12739 
12740   ;;
12741 esac
12742 fi
12743 WHICH=$ac_cv_path_WHICH
12744 if test -n "$WHICH"; then
12745   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
12746 $as_echo "$WHICH" >&6; }
12747 else
12748   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12749 $as_echo "no" >&6; }
12750 fi
12751 
12752 
12753   test -n "$WHICH" && break
12754 done
12755 
12756   else
12757     # The variable is set, but is it from the command line or the environment?
12758 
12759     # Try to remove the string !WHICH! from our list.
12760     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!WHICH!/}
12761     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12762       # If it failed, the variable was not from the command line. Ignore it,
12763       # but warn the user (except for BASH, which is always set by the calling BASH).
12764       if test "xWHICH" != xBASH; then
12765         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of WHICH from the environment. Use command line variables instead." >&5
12766 $as_echo "$as_me: WARNING: Ignoring value of WHICH from the environment. Use command line variables instead." >&2;}
12767       fi
12768       # Try to locate tool using the code snippet
12769       for ac_prog in which
12770 do
12771   # Extract the first word of "$ac_prog", so it can be a program name with args.
12772 set dummy $ac_prog; ac_word=$2
12773 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12774 $as_echo_n "checking for $ac_word... " >&6; }
12775 if ${ac_cv_path_WHICH+:} false; then :
12776   $as_echo_n "(cached) " >&6
12777 else
12778   case $WHICH in
12779   [\\/]* | ?:[\\/]*)
12780   ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
12781   ;;
12782   *)
12783   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12784 for as_dir in $PATH
12785 do
12786   IFS=$as_save_IFS
12787   test -z "$as_dir" && as_dir=.
12788     for ac_exec_ext in '' $ac_executable_extensions; do
12789   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12790     ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
12791     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12792     break 2
12793   fi
12794 done
12795   done
12796 IFS=$as_save_IFS
12797 
12798   ;;
12799 esac
12800 fi
12801 WHICH=$ac_cv_path_WHICH
12802 if test -n "$WHICH"; then
12803   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
12804 $as_echo "$WHICH" >&6; }
12805 else
12806   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12807 $as_echo "no" >&6; }
12808 fi
12809 
12810 
12811   test -n "$WHICH" && break
12812 done
12813 
12814     else
12815       # If it succeeded, then it was overridden by the user. We will use it
12816       # for the tool.
12817 
12818       # First remove it from the list of overridden variables, so we can test
12819       # for unknown variables in the end.
12820       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12821 
12822       # Check if we try to supply an empty value
12823       if test "x$WHICH" = x; then
12824         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool WHICH= (no value)" >&5
12825 $as_echo "$as_me: Setting user supplied tool WHICH= (no value)" >&6;}
12826         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WHICH" >&5
12827 $as_echo_n "checking for WHICH... " >&6; }
12828         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
12829 $as_echo "disabled" >&6; }
12830       else
12831         # Check if the provided tool contains a complete path.
12832         tool_specified="$WHICH"
12833         tool_basename="${tool_specified##*/}"
12834         if test "x$tool_basename" = "x$tool_specified"; then
12835           # A command without a complete path is provided, search $PATH.
12836           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool WHICH=$tool_basename" >&5
12837 $as_echo "$as_me: Will search for user supplied tool WHICH=$tool_basename" >&6;}
12838           # Extract the first word of "$tool_basename", so it can be a program name with args.
12839 set dummy $tool_basename; ac_word=$2
12840 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12841 $as_echo_n "checking for $ac_word... " >&6; }
12842 if ${ac_cv_path_WHICH+:} false; then :
12843   $as_echo_n "(cached) " >&6
12844 else
12845   case $WHICH in
12846   [\\/]* | ?:[\\/]*)
12847   ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
12848   ;;
12849   *)
12850   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12851 for as_dir in $PATH
12852 do
12853   IFS=$as_save_IFS
12854   test -z "$as_dir" && as_dir=.
12855     for ac_exec_ext in '' $ac_executable_extensions; do
12856   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12857     ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
12858     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12859     break 2
12860   fi
12861 done
12862   done
12863 IFS=$as_save_IFS
12864 
12865   ;;
12866 esac
12867 fi
12868 WHICH=$ac_cv_path_WHICH
12869 if test -n "$WHICH"; then
12870   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
12871 $as_echo "$WHICH" >&6; }
12872 else
12873   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12874 $as_echo "no" >&6; }
12875 fi
12876 
12877 
12878           if test "x$WHICH" = x; then
12879             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12880           fi
12881         else
12882           # Otherwise we believe it is a complete path. Use it as it is.
12883           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool WHICH=$tool_specified" >&5
12884 $as_echo "$as_me: Will use user supplied tool WHICH=$tool_specified" >&6;}
12885           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WHICH" >&5
12886 $as_echo_n "checking for WHICH... " >&6; }
12887           if test ! -x "$tool_specified"; then
12888             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12889 $as_echo "not found" >&6; }
12890             as_fn_error $? "User supplied tool WHICH=$tool_specified does not exist or is not executable" "$LINENO" 5
12891           fi
12892           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12893 $as_echo "$tool_specified" >&6; }
12894         fi
12895       fi
12896     fi
12897 
12898   fi
12899 
12900 
12901 
12902   if test "x$WHICH" = x; then
12903     as_fn_error $? "Could not find required tool for WHICH" "$LINENO" 5
12904   fi
12905 
12906 
12907 
12908 
12909 
12910   # Publish this variable in the help.
12911 
12912 
12913   if [ -z "${XARGS+x}" ]; then
12914     # The variable is not set by user, try to locate tool using the code snippet
12915     for ac_prog in xargs
12916 do
12917   # Extract the first word of "$ac_prog", so it can be a program name with args.
12918 set dummy $ac_prog; ac_word=$2
12919 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12920 $as_echo_n "checking for $ac_word... " >&6; }
12921 if ${ac_cv_path_XARGS+:} false; then :
12922   $as_echo_n "(cached) " >&6
12923 else
12924   case $XARGS in
12925   [\\/]* | ?:[\\/]*)
12926   ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
12927   ;;
12928   *)
12929   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12930 for as_dir in $PATH
12931 do
12932   IFS=$as_save_IFS
12933   test -z "$as_dir" && as_dir=.
12934     for ac_exec_ext in '' $ac_executable_extensions; do
12935   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12936     ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
12937     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12938     break 2
12939   fi
12940 done
12941   done
12942 IFS=$as_save_IFS
12943 
12944   ;;
12945 esac
12946 fi
12947 XARGS=$ac_cv_path_XARGS
12948 if test -n "$XARGS"; then
12949   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
12950 $as_echo "$XARGS" >&6; }
12951 else
12952   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12953 $as_echo "no" >&6; }
12954 fi
12955 
12956 
12957   test -n "$XARGS" && break
12958 done
12959 
12960   else
12961     # The variable is set, but is it from the command line or the environment?
12962 
12963     # Try to remove the string !XARGS! from our list.
12964     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!XARGS!/}
12965     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12966       # If it failed, the variable was not from the command line. Ignore it,
12967       # but warn the user (except for BASH, which is always set by the calling BASH).
12968       if test "xXARGS" != xBASH; then
12969         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of XARGS from the environment. Use command line variables instead." >&5
12970 $as_echo "$as_me: WARNING: Ignoring value of XARGS from the environment. Use command line variables instead." >&2;}
12971       fi
12972       # Try to locate tool using the code snippet
12973       for ac_prog in xargs
12974 do
12975   # Extract the first word of "$ac_prog", so it can be a program name with args.
12976 set dummy $ac_prog; ac_word=$2
12977 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12978 $as_echo_n "checking for $ac_word... " >&6; }
12979 if ${ac_cv_path_XARGS+:} false; then :
12980   $as_echo_n "(cached) " >&6
12981 else
12982   case $XARGS in
12983   [\\/]* | ?:[\\/]*)
12984   ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
12985   ;;
12986   *)
12987   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12988 for as_dir in $PATH
12989 do
12990   IFS=$as_save_IFS
12991   test -z "$as_dir" && as_dir=.
12992     for ac_exec_ext in '' $ac_executable_extensions; do
12993   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12994     ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
12995     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12996     break 2
12997   fi
12998 done
12999   done
13000 IFS=$as_save_IFS
13001 
13002   ;;
13003 esac
13004 fi
13005 XARGS=$ac_cv_path_XARGS
13006 if test -n "$XARGS"; then
13007   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
13008 $as_echo "$XARGS" >&6; }
13009 else
13010   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13011 $as_echo "no" >&6; }
13012 fi
13013 
13014 
13015   test -n "$XARGS" && break
13016 done
13017 
13018     else
13019       # If it succeeded, then it was overridden by the user. We will use it
13020       # for the tool.
13021 
13022       # First remove it from the list of overridden variables, so we can test
13023       # for unknown variables in the end.
13024       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13025 
13026       # Check if we try to supply an empty value
13027       if test "x$XARGS" = x; then
13028         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool XARGS= (no value)" >&5
13029 $as_echo "$as_me: Setting user supplied tool XARGS= (no value)" >&6;}
13030         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XARGS" >&5
13031 $as_echo_n "checking for XARGS... " >&6; }
13032         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
13033 $as_echo "disabled" >&6; }
13034       else
13035         # Check if the provided tool contains a complete path.
13036         tool_specified="$XARGS"
13037         tool_basename="${tool_specified##*/}"
13038         if test "x$tool_basename" = "x$tool_specified"; then
13039           # A command without a complete path is provided, search $PATH.
13040           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool XARGS=$tool_basename" >&5
13041 $as_echo "$as_me: Will search for user supplied tool XARGS=$tool_basename" >&6;}
13042           # Extract the first word of "$tool_basename", so it can be a program name with args.
13043 set dummy $tool_basename; ac_word=$2
13044 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13045 $as_echo_n "checking for $ac_word... " >&6; }
13046 if ${ac_cv_path_XARGS+:} false; then :
13047   $as_echo_n "(cached) " >&6
13048 else
13049   case $XARGS in
13050   [\\/]* | ?:[\\/]*)
13051   ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
13052   ;;
13053   *)
13054   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13055 for as_dir in $PATH
13056 do
13057   IFS=$as_save_IFS
13058   test -z "$as_dir" && as_dir=.
13059     for ac_exec_ext in '' $ac_executable_extensions; do
13060   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13061     ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
13062     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13063     break 2
13064   fi
13065 done
13066   done
13067 IFS=$as_save_IFS
13068 
13069   ;;
13070 esac
13071 fi
13072 XARGS=$ac_cv_path_XARGS
13073 if test -n "$XARGS"; then
13074   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
13075 $as_echo "$XARGS" >&6; }
13076 else
13077   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13078 $as_echo "no" >&6; }
13079 fi
13080 
13081 
13082           if test "x$XARGS" = x; then
13083             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13084           fi
13085         else
13086           # Otherwise we believe it is a complete path. Use it as it is.
13087           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool XARGS=$tool_specified" >&5
13088 $as_echo "$as_me: Will use user supplied tool XARGS=$tool_specified" >&6;}
13089           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XARGS" >&5
13090 $as_echo_n "checking for XARGS... " >&6; }
13091           if test ! -x "$tool_specified"; then
13092             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13093 $as_echo "not found" >&6; }
13094             as_fn_error $? "User supplied tool XARGS=$tool_specified does not exist or is not executable" "$LINENO" 5
13095           fi
13096           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13097 $as_echo "$tool_specified" >&6; }
13098         fi
13099       fi
13100     fi
13101 
13102   fi
13103 
13104 
13105 
13106   if test "x$XARGS" = x; then
13107     as_fn_error $? "Could not find required tool for XARGS" "$LINENO" 5
13108   fi
13109 
13110 
13111 
13112   # Then required tools that require some special treatment.
13113 
13114 
13115   # Publish this variable in the help.
13116 
13117 
13118   if [ -z "${AWK+x}" ]; then
13119     # The variable is not set by user, try to locate tool using the code snippet
13120     for ac_prog in gawk mawk nawk awk
13121 do
13122   # Extract the first word of "$ac_prog", so it can be a program name with args.
13123 set dummy $ac_prog; ac_word=$2
13124 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13125 $as_echo_n "checking for $ac_word... " >&6; }
13126 if ${ac_cv_prog_AWK+:} false; then :
13127   $as_echo_n "(cached) " >&6
13128 else
13129   if test -n "$AWK"; then
13130   ac_cv_prog_AWK="$AWK" # Let the user override the test.
13131 else
13132 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13133 for as_dir in $PATH
13134 do
13135   IFS=$as_save_IFS
13136   test -z "$as_dir" && as_dir=.
13137     for ac_exec_ext in '' $ac_executable_extensions; do
13138   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13139     ac_cv_prog_AWK="$ac_prog"
13140     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13141     break 2
13142   fi
13143 done
13144   done
13145 IFS=$as_save_IFS
13146 
13147 fi
13148 fi
13149 AWK=$ac_cv_prog_AWK
13150 if test -n "$AWK"; then
13151   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
13152 $as_echo "$AWK" >&6; }
13153 else
13154   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13155 $as_echo "no" >&6; }
13156 fi
13157 
13158 
13159   test -n "$AWK" && break
13160 done
13161 
13162   else
13163     # The variable is set, but is it from the command line or the environment?
13164 
13165     # Try to remove the string !AWK! from our list.
13166     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!AWK!/}
13167     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
13168       # If it failed, the variable was not from the command line. Ignore it,
13169       # but warn the user (except for BASH, which is always set by the calling BASH).
13170       if test "xAWK" != xBASH; then
13171         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of AWK from the environment. Use command line variables instead." >&5
13172 $as_echo "$as_me: WARNING: Ignoring value of AWK from the environment. Use command line variables instead." >&2;}
13173       fi
13174       # Try to locate tool using the code snippet
13175       for ac_prog in gawk mawk nawk awk
13176 do
13177   # Extract the first word of "$ac_prog", so it can be a program name with args.
13178 set dummy $ac_prog; ac_word=$2
13179 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13180 $as_echo_n "checking for $ac_word... " >&6; }
13181 if ${ac_cv_prog_AWK+:} false; then :
13182   $as_echo_n "(cached) " >&6
13183 else
13184   if test -n "$AWK"; then
13185   ac_cv_prog_AWK="$AWK" # Let the user override the test.
13186 else
13187 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13188 for as_dir in $PATH
13189 do
13190   IFS=$as_save_IFS
13191   test -z "$as_dir" && as_dir=.
13192     for ac_exec_ext in '' $ac_executable_extensions; do
13193   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13194     ac_cv_prog_AWK="$ac_prog"
13195     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13196     break 2
13197   fi
13198 done
13199   done
13200 IFS=$as_save_IFS
13201 
13202 fi
13203 fi
13204 AWK=$ac_cv_prog_AWK
13205 if test -n "$AWK"; then
13206   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
13207 $as_echo "$AWK" >&6; }
13208 else
13209   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13210 $as_echo "no" >&6; }
13211 fi
13212 
13213 
13214   test -n "$AWK" && break
13215 done
13216 
13217     else
13218       # If it succeeded, then it was overridden by the user. We will use it
13219       # for the tool.
13220 
13221       # First remove it from the list of overridden variables, so we can test
13222       # for unknown variables in the end.
13223       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13224 
13225       # Check if we try to supply an empty value
13226       if test "x$AWK" = x; then
13227         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool AWK= (no value)" >&5
13228 $as_echo "$as_me: Setting user supplied tool AWK= (no value)" >&6;}
13229         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for AWK" >&5
13230 $as_echo_n "checking for AWK... " >&6; }
13231         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
13232 $as_echo "disabled" >&6; }
13233       else
13234         # Check if the provided tool contains a complete path.
13235         tool_specified="$AWK"
13236         tool_basename="${tool_specified##*/}"
13237         if test "x$tool_basename" = "x$tool_specified"; then
13238           # A command without a complete path is provided, search $PATH.
13239           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool AWK=$tool_basename" >&5
13240 $as_echo "$as_me: Will search for user supplied tool AWK=$tool_basename" >&6;}
13241           # Extract the first word of "$tool_basename", so it can be a program name with args.
13242 set dummy $tool_basename; ac_word=$2
13243 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13244 $as_echo_n "checking for $ac_word... " >&6; }
13245 if ${ac_cv_path_AWK+:} false; then :
13246   $as_echo_n "(cached) " >&6
13247 else
13248   case $AWK in
13249   [\\/]* | ?:[\\/]*)
13250   ac_cv_path_AWK="$AWK" # Let the user override the test with a path.
13251   ;;
13252   *)
13253   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13254 for as_dir in $PATH
13255 do
13256   IFS=$as_save_IFS
13257   test -z "$as_dir" && as_dir=.
13258     for ac_exec_ext in '' $ac_executable_extensions; do
13259   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13260     ac_cv_path_AWK="$as_dir/$ac_word$ac_exec_ext"
13261     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13262     break 2
13263   fi
13264 done
13265   done
13266 IFS=$as_save_IFS
13267 
13268   ;;
13269 esac
13270 fi
13271 AWK=$ac_cv_path_AWK
13272 if test -n "$AWK"; then
13273   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
13274 $as_echo "$AWK" >&6; }
13275 else
13276   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13277 $as_echo "no" >&6; }
13278 fi
13279 
13280 
13281           if test "x$AWK" = x; then
13282             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13283           fi
13284         else
13285           # Otherwise we believe it is a complete path. Use it as it is.
13286           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool AWK=$tool_specified" >&5
13287 $as_echo "$as_me: Will use user supplied tool AWK=$tool_specified" >&6;}
13288           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for AWK" >&5
13289 $as_echo_n "checking for AWK... " >&6; }
13290           if test ! -x "$tool_specified"; then
13291             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13292 $as_echo "not found" >&6; }
13293             as_fn_error $? "User supplied tool AWK=$tool_specified does not exist or is not executable" "$LINENO" 5
13294           fi
13295           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13296 $as_echo "$tool_specified" >&6; }
13297         fi
13298       fi
13299     fi
13300 
13301   fi
13302 
13303 
13304   if test "x$AWK" = x; then
13305     as_fn_error $? "Could not find required tool for AWK" "$LINENO" 5
13306   fi
13307 
13308 
13309 
13310 
13311   # Publish this variable in the help.
13312 
13313 
13314   if [ -z "${GREP+x}" ]; then
13315     # The variable is not set by user, try to locate tool using the code snippet
13316     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
13317 $as_echo_n "checking for grep that handles long lines and -e... " >&6; }
13318 if ${ac_cv_path_GREP+:} false; then :
13319   $as_echo_n "(cached) " >&6
13320 else
13321   if test -z "$GREP"; then
13322   ac_path_GREP_found=false
13323   # Loop through the user's path and test for each of PROGNAME-LIST
13324   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13325 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
13326 do
13327   IFS=$as_save_IFS
13328   test -z "$as_dir" && as_dir=.
13329     for ac_prog in grep ggrep; do
13330     for ac_exec_ext in '' $ac_executable_extensions; do
13331       ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
13332       as_fn_executable_p "$ac_path_GREP" || continue
13333 # Check for GNU ac_path_GREP and select it if it is found.
13334   # Check for GNU $ac_path_GREP
13335 case `"$ac_path_GREP" --version 2>&1` in
13336 *GNU*)
13337   ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
13338 *)
13339   ac_count=0
13340   $as_echo_n 0123456789 >"conftest.in"
13341   while :
13342   do
13343     cat "conftest.in" "conftest.in" >"conftest.tmp"
13344     mv "conftest.tmp" "conftest.in"
13345     cp "conftest.in" "conftest.nl"
13346     $as_echo 'GREP' >> "conftest.nl"
13347     "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
13348     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
13349     as_fn_arith $ac_count + 1 && ac_count=$as_val
13350     if test $ac_count -gt ${ac_path_GREP_max-0}; then
13351       # Best one so far, save it but keep looking for a better one
13352       ac_cv_path_GREP="$ac_path_GREP"
13353       ac_path_GREP_max=$ac_count
13354     fi
13355     # 10*(2^10) chars as input seems more than enough
13356     test $ac_count -gt 10 && break
13357   done
13358   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
13359 esac
13360 
13361       $ac_path_GREP_found && break 3
13362     done
13363   done
13364   done
13365 IFS=$as_save_IFS
13366   if test -z "$ac_cv_path_GREP"; then
13367     as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
13368   fi
13369 else
13370   ac_cv_path_GREP=$GREP
13371 fi
13372 
13373 fi
13374 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
13375 $as_echo "$ac_cv_path_GREP" >&6; }
13376  GREP="$ac_cv_path_GREP"
13377 
13378 
13379   else
13380     # The variable is set, but is it from the command line or the environment?
13381 
13382     # Try to remove the string !GREP! from our list.
13383     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!GREP!/}
13384     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
13385       # If it failed, the variable was not from the command line. Ignore it,
13386       # but warn the user (except for BASH, which is always set by the calling BASH).
13387       if test "xGREP" != xBASH; then
13388         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of GREP from the environment. Use command line variables instead." >&5
13389 $as_echo "$as_me: WARNING: Ignoring value of GREP from the environment. Use command line variables instead." >&2;}
13390       fi
13391       # Try to locate tool using the code snippet
13392       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
13393 $as_echo_n "checking for grep that handles long lines and -e... " >&6; }
13394 if ${ac_cv_path_GREP+:} false; then :
13395   $as_echo_n "(cached) " >&6
13396 else
13397   if test -z "$GREP"; then
13398   ac_path_GREP_found=false
13399   # Loop through the user's path and test for each of PROGNAME-LIST
13400   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13401 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
13402 do
13403   IFS=$as_save_IFS
13404   test -z "$as_dir" && as_dir=.
13405     for ac_prog in grep ggrep; do
13406     for ac_exec_ext in '' $ac_executable_extensions; do
13407       ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
13408       as_fn_executable_p "$ac_path_GREP" || continue
13409 # Check for GNU ac_path_GREP and select it if it is found.
13410   # Check for GNU $ac_path_GREP
13411 case `"$ac_path_GREP" --version 2>&1` in
13412 *GNU*)
13413   ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
13414 *)
13415   ac_count=0
13416   $as_echo_n 0123456789 >"conftest.in"
13417   while :
13418   do
13419     cat "conftest.in" "conftest.in" >"conftest.tmp"
13420     mv "conftest.tmp" "conftest.in"
13421     cp "conftest.in" "conftest.nl"
13422     $as_echo 'GREP' >> "conftest.nl"
13423     "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
13424     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
13425     as_fn_arith $ac_count + 1 && ac_count=$as_val
13426     if test $ac_count -gt ${ac_path_GREP_max-0}; then
13427       # Best one so far, save it but keep looking for a better one
13428       ac_cv_path_GREP="$ac_path_GREP"
13429       ac_path_GREP_max=$ac_count
13430     fi
13431     # 10*(2^10) chars as input seems more than enough
13432     test $ac_count -gt 10 && break
13433   done
13434   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
13435 esac
13436 
13437       $ac_path_GREP_found && break 3
13438     done
13439   done
13440   done
13441 IFS=$as_save_IFS
13442   if test -z "$ac_cv_path_GREP"; then
13443     as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
13444   fi
13445 else
13446   ac_cv_path_GREP=$GREP
13447 fi
13448 
13449 fi
13450 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
13451 $as_echo "$ac_cv_path_GREP" >&6; }
13452  GREP="$ac_cv_path_GREP"
13453 
13454 
13455     else
13456       # If it succeeded, then it was overridden by the user. We will use it
13457       # for the tool.
13458 
13459       # First remove it from the list of overridden variables, so we can test
13460       # for unknown variables in the end.
13461       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13462 
13463       # Check if we try to supply an empty value
13464       if test "x$GREP" = x; then
13465         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool GREP= (no value)" >&5
13466 $as_echo "$as_me: Setting user supplied tool GREP= (no value)" >&6;}
13467         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GREP" >&5
13468 $as_echo_n "checking for GREP... " >&6; }
13469         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
13470 $as_echo "disabled" >&6; }
13471       else
13472         # Check if the provided tool contains a complete path.
13473         tool_specified="$GREP"
13474         tool_basename="${tool_specified##*/}"
13475         if test "x$tool_basename" = "x$tool_specified"; then
13476           # A command without a complete path is provided, search $PATH.
13477           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool GREP=$tool_basename" >&5
13478 $as_echo "$as_me: Will search for user supplied tool GREP=$tool_basename" >&6;}
13479           # Extract the first word of "$tool_basename", so it can be a program name with args.
13480 set dummy $tool_basename; ac_word=$2
13481 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13482 $as_echo_n "checking for $ac_word... " >&6; }
13483 if ${ac_cv_path_GREP+:} false; then :
13484   $as_echo_n "(cached) " >&6
13485 else
13486   case $GREP in
13487   [\\/]* | ?:[\\/]*)
13488   ac_cv_path_GREP="$GREP" # Let the user override the test with a path.
13489   ;;
13490   *)
13491   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13492 for as_dir in $PATH
13493 do
13494   IFS=$as_save_IFS
13495   test -z "$as_dir" && as_dir=.
13496     for ac_exec_ext in '' $ac_executable_extensions; do
13497   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13498     ac_cv_path_GREP="$as_dir/$ac_word$ac_exec_ext"
13499     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13500     break 2
13501   fi
13502 done
13503   done
13504 IFS=$as_save_IFS
13505 
13506   ;;
13507 esac
13508 fi
13509 GREP=$ac_cv_path_GREP
13510 if test -n "$GREP"; then
13511   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GREP" >&5
13512 $as_echo "$GREP" >&6; }
13513 else
13514   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13515 $as_echo "no" >&6; }
13516 fi
13517 
13518 
13519           if test "x$GREP" = x; then
13520             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13521           fi
13522         else
13523           # Otherwise we believe it is a complete path. Use it as it is.
13524           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool GREP=$tool_specified" >&5
13525 $as_echo "$as_me: Will use user supplied tool GREP=$tool_specified" >&6;}
13526           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GREP" >&5
13527 $as_echo_n "checking for GREP... " >&6; }
13528           if test ! -x "$tool_specified"; then
13529             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13530 $as_echo "not found" >&6; }
13531             as_fn_error $? "User supplied tool GREP=$tool_specified does not exist or is not executable" "$LINENO" 5
13532           fi
13533           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13534 $as_echo "$tool_specified" >&6; }
13535         fi
13536       fi
13537     fi
13538 
13539   fi
13540 
13541 
13542   if test "x$GREP" = x; then
13543     as_fn_error $? "Could not find required tool for GREP" "$LINENO" 5
13544   fi
13545 
13546 
13547 
13548 
13549   # Publish this variable in the help.
13550 
13551 
13552   if [ -z "${EGREP+x}" ]; then
13553     # The variable is not set by user, try to locate tool using the code snippet
13554     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
13555 $as_echo_n "checking for egrep... " >&6; }
13556 if ${ac_cv_path_EGREP+:} false; then :
13557   $as_echo_n "(cached) " >&6
13558 else
13559   if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
13560    then ac_cv_path_EGREP="$GREP -E"
13561    else
13562      if test -z "$EGREP"; then
13563   ac_path_EGREP_found=false
13564   # Loop through the user's path and test for each of PROGNAME-LIST
13565   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13566 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
13567 do
13568   IFS=$as_save_IFS
13569   test -z "$as_dir" && as_dir=.
13570     for ac_prog in egrep; do
13571     for ac_exec_ext in '' $ac_executable_extensions; do
13572       ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
13573       as_fn_executable_p "$ac_path_EGREP" || continue
13574 # Check for GNU ac_path_EGREP and select it if it is found.
13575   # Check for GNU $ac_path_EGREP
13576 case `"$ac_path_EGREP" --version 2>&1` in
13577 *GNU*)
13578   ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
13579 *)
13580   ac_count=0
13581   $as_echo_n 0123456789 >"conftest.in"
13582   while :
13583   do
13584     cat "conftest.in" "conftest.in" >"conftest.tmp"
13585     mv "conftest.tmp" "conftest.in"
13586     cp "conftest.in" "conftest.nl"
13587     $as_echo 'EGREP' >> "conftest.nl"
13588     "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
13589     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
13590     as_fn_arith $ac_count + 1 && ac_count=$as_val
13591     if test $ac_count -gt ${ac_path_EGREP_max-0}; then
13592       # Best one so far, save it but keep looking for a better one
13593       ac_cv_path_EGREP="$ac_path_EGREP"
13594       ac_path_EGREP_max=$ac_count
13595     fi
13596     # 10*(2^10) chars as input seems more than enough
13597     test $ac_count -gt 10 && break
13598   done
13599   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
13600 esac
13601 
13602       $ac_path_EGREP_found && break 3
13603     done
13604   done
13605   done
13606 IFS=$as_save_IFS
13607   if test -z "$ac_cv_path_EGREP"; then
13608     as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
13609   fi
13610 else
13611   ac_cv_path_EGREP=$EGREP
13612 fi
13613 
13614    fi
13615 fi
13616 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
13617 $as_echo "$ac_cv_path_EGREP" >&6; }
13618  EGREP="$ac_cv_path_EGREP"
13619 
13620 
13621   else
13622     # The variable is set, but is it from the command line or the environment?
13623 
13624     # Try to remove the string !EGREP! from our list.
13625     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!EGREP!/}
13626     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
13627       # If it failed, the variable was not from the command line. Ignore it,
13628       # but warn the user (except for BASH, which is always set by the calling BASH).
13629       if test "xEGREP" != xBASH; then
13630         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of EGREP from the environment. Use command line variables instead." >&5
13631 $as_echo "$as_me: WARNING: Ignoring value of EGREP from the environment. Use command line variables instead." >&2;}
13632       fi
13633       # Try to locate tool using the code snippet
13634       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
13635 $as_echo_n "checking for egrep... " >&6; }
13636 if ${ac_cv_path_EGREP+:} false; then :
13637   $as_echo_n "(cached) " >&6
13638 else
13639   if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
13640    then ac_cv_path_EGREP="$GREP -E"
13641    else
13642      if test -z "$EGREP"; then
13643   ac_path_EGREP_found=false
13644   # Loop through the user's path and test for each of PROGNAME-LIST
13645   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13646 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
13647 do
13648   IFS=$as_save_IFS
13649   test -z "$as_dir" && as_dir=.
13650     for ac_prog in egrep; do
13651     for ac_exec_ext in '' $ac_executable_extensions; do
13652       ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
13653       as_fn_executable_p "$ac_path_EGREP" || continue
13654 # Check for GNU ac_path_EGREP and select it if it is found.
13655   # Check for GNU $ac_path_EGREP
13656 case `"$ac_path_EGREP" --version 2>&1` in
13657 *GNU*)
13658   ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
13659 *)
13660   ac_count=0
13661   $as_echo_n 0123456789 >"conftest.in"
13662   while :
13663   do
13664     cat "conftest.in" "conftest.in" >"conftest.tmp"
13665     mv "conftest.tmp" "conftest.in"
13666     cp "conftest.in" "conftest.nl"
13667     $as_echo 'EGREP' >> "conftest.nl"
13668     "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
13669     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
13670     as_fn_arith $ac_count + 1 && ac_count=$as_val
13671     if test $ac_count -gt ${ac_path_EGREP_max-0}; then
13672       # Best one so far, save it but keep looking for a better one
13673       ac_cv_path_EGREP="$ac_path_EGREP"
13674       ac_path_EGREP_max=$ac_count
13675     fi
13676     # 10*(2^10) chars as input seems more than enough
13677     test $ac_count -gt 10 && break
13678   done
13679   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
13680 esac
13681 
13682       $ac_path_EGREP_found && break 3
13683     done
13684   done
13685   done
13686 IFS=$as_save_IFS
13687   if test -z "$ac_cv_path_EGREP"; then
13688     as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
13689   fi
13690 else
13691   ac_cv_path_EGREP=$EGREP
13692 fi
13693 
13694    fi
13695 fi
13696 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
13697 $as_echo "$ac_cv_path_EGREP" >&6; }
13698  EGREP="$ac_cv_path_EGREP"
13699 
13700 
13701     else
13702       # If it succeeded, then it was overridden by the user. We will use it
13703       # for the tool.
13704 
13705       # First remove it from the list of overridden variables, so we can test
13706       # for unknown variables in the end.
13707       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13708 
13709       # Check if we try to supply an empty value
13710       if test "x$EGREP" = x; then
13711         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool EGREP= (no value)" >&5
13712 $as_echo "$as_me: Setting user supplied tool EGREP= (no value)" >&6;}
13713         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EGREP" >&5
13714 $as_echo_n "checking for EGREP... " >&6; }
13715         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
13716 $as_echo "disabled" >&6; }
13717       else
13718         # Check if the provided tool contains a complete path.
13719         tool_specified="$EGREP"
13720         tool_basename="${tool_specified##*/}"
13721         if test "x$tool_basename" = "x$tool_specified"; then
13722           # A command without a complete path is provided, search $PATH.
13723           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool EGREP=$tool_basename" >&5
13724 $as_echo "$as_me: Will search for user supplied tool EGREP=$tool_basename" >&6;}
13725           # Extract the first word of "$tool_basename", so it can be a program name with args.
13726 set dummy $tool_basename; ac_word=$2
13727 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13728 $as_echo_n "checking for $ac_word... " >&6; }
13729 if ${ac_cv_path_EGREP+:} false; then :
13730   $as_echo_n "(cached) " >&6
13731 else
13732   case $EGREP in
13733   [\\/]* | ?:[\\/]*)
13734   ac_cv_path_EGREP="$EGREP" # Let the user override the test with a path.
13735   ;;
13736   *)
13737   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13738 for as_dir in $PATH
13739 do
13740   IFS=$as_save_IFS
13741   test -z "$as_dir" && as_dir=.
13742     for ac_exec_ext in '' $ac_executable_extensions; do
13743   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13744     ac_cv_path_EGREP="$as_dir/$ac_word$ac_exec_ext"
13745     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13746     break 2
13747   fi
13748 done
13749   done
13750 IFS=$as_save_IFS
13751 
13752   ;;
13753 esac
13754 fi
13755 EGREP=$ac_cv_path_EGREP
13756 if test -n "$EGREP"; then
13757   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EGREP" >&5
13758 $as_echo "$EGREP" >&6; }
13759 else
13760   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13761 $as_echo "no" >&6; }
13762 fi
13763 
13764 
13765           if test "x$EGREP" = x; then
13766             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13767           fi
13768         else
13769           # Otherwise we believe it is a complete path. Use it as it is.
13770           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool EGREP=$tool_specified" >&5
13771 $as_echo "$as_me: Will use user supplied tool EGREP=$tool_specified" >&6;}
13772           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EGREP" >&5
13773 $as_echo_n "checking for EGREP... " >&6; }
13774           if test ! -x "$tool_specified"; then
13775             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13776 $as_echo "not found" >&6; }
13777             as_fn_error $? "User supplied tool EGREP=$tool_specified does not exist or is not executable" "$LINENO" 5
13778           fi
13779           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13780 $as_echo "$tool_specified" >&6; }
13781         fi
13782       fi
13783     fi
13784 
13785   fi
13786 
13787 
13788   if test "x$EGREP" = x; then
13789     as_fn_error $? "Could not find required tool for EGREP" "$LINENO" 5
13790   fi
13791 
13792 
13793 
13794 
13795   # Publish this variable in the help.
13796 
13797 
13798   if [ -z "${FGREP+x}" ]; then
13799     # The variable is not set by user, try to locate tool using the code snippet
13800     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
13801 $as_echo_n "checking for fgrep... " >&6; }
13802 if ${ac_cv_path_FGREP+:} false; then :
13803   $as_echo_n "(cached) " >&6
13804 else
13805   if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
13806    then ac_cv_path_FGREP="$GREP -F"
13807    else
13808      if test -z "$FGREP"; then
13809   ac_path_FGREP_found=false
13810   # Loop through the user's path and test for each of PROGNAME-LIST
13811   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13812 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
13813 do
13814   IFS=$as_save_IFS
13815   test -z "$as_dir" && as_dir=.
13816     for ac_prog in fgrep; do
13817     for ac_exec_ext in '' $ac_executable_extensions; do
13818       ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
13819       as_fn_executable_p "$ac_path_FGREP" || continue
13820 # Check for GNU ac_path_FGREP and select it if it is found.
13821   # Check for GNU $ac_path_FGREP
13822 case `"$ac_path_FGREP" --version 2>&1` in
13823 *GNU*)
13824   ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
13825 *)
13826   ac_count=0
13827   $as_echo_n 0123456789 >"conftest.in"
13828   while :
13829   do
13830     cat "conftest.in" "conftest.in" >"conftest.tmp"
13831     mv "conftest.tmp" "conftest.in"
13832     cp "conftest.in" "conftest.nl"
13833     $as_echo 'FGREP' >> "conftest.nl"
13834     "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
13835     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
13836     as_fn_arith $ac_count + 1 && ac_count=$as_val
13837     if test $ac_count -gt ${ac_path_FGREP_max-0}; then
13838       # Best one so far, save it but keep looking for a better one
13839       ac_cv_path_FGREP="$ac_path_FGREP"
13840       ac_path_FGREP_max=$ac_count
13841     fi
13842     # 10*(2^10) chars as input seems more than enough
13843     test $ac_count -gt 10 && break
13844   done
13845   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
13846 esac
13847 
13848       $ac_path_FGREP_found && break 3
13849     done
13850   done
13851   done
13852 IFS=$as_save_IFS
13853   if test -z "$ac_cv_path_FGREP"; then
13854     as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
13855   fi
13856 else
13857   ac_cv_path_FGREP=$FGREP
13858 fi
13859 
13860    fi
13861 fi
13862 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
13863 $as_echo "$ac_cv_path_FGREP" >&6; }
13864  FGREP="$ac_cv_path_FGREP"
13865 
13866 
13867   else
13868     # The variable is set, but is it from the command line or the environment?
13869 
13870     # Try to remove the string !FGREP! from our list.
13871     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FGREP!/}
13872     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
13873       # If it failed, the variable was not from the command line. Ignore it,
13874       # but warn the user (except for BASH, which is always set by the calling BASH).
13875       if test "xFGREP" != xBASH; then
13876         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FGREP from the environment. Use command line variables instead." >&5
13877 $as_echo "$as_me: WARNING: Ignoring value of FGREP from the environment. Use command line variables instead." >&2;}
13878       fi
13879       # Try to locate tool using the code snippet
13880       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
13881 $as_echo_n "checking for fgrep... " >&6; }
13882 if ${ac_cv_path_FGREP+:} false; then :
13883   $as_echo_n "(cached) " >&6
13884 else
13885   if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
13886    then ac_cv_path_FGREP="$GREP -F"
13887    else
13888      if test -z "$FGREP"; then
13889   ac_path_FGREP_found=false
13890   # Loop through the user's path and test for each of PROGNAME-LIST
13891   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13892 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
13893 do
13894   IFS=$as_save_IFS
13895   test -z "$as_dir" && as_dir=.
13896     for ac_prog in fgrep; do
13897     for ac_exec_ext in '' $ac_executable_extensions; do
13898       ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
13899       as_fn_executable_p "$ac_path_FGREP" || continue
13900 # Check for GNU ac_path_FGREP and select it if it is found.
13901   # Check for GNU $ac_path_FGREP
13902 case `"$ac_path_FGREP" --version 2>&1` in
13903 *GNU*)
13904   ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
13905 *)
13906   ac_count=0
13907   $as_echo_n 0123456789 >"conftest.in"
13908   while :
13909   do
13910     cat "conftest.in" "conftest.in" >"conftest.tmp"
13911     mv "conftest.tmp" "conftest.in"
13912     cp "conftest.in" "conftest.nl"
13913     $as_echo 'FGREP' >> "conftest.nl"
13914     "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
13915     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
13916     as_fn_arith $ac_count + 1 && ac_count=$as_val
13917     if test $ac_count -gt ${ac_path_FGREP_max-0}; then
13918       # Best one so far, save it but keep looking for a better one
13919       ac_cv_path_FGREP="$ac_path_FGREP"
13920       ac_path_FGREP_max=$ac_count
13921     fi
13922     # 10*(2^10) chars as input seems more than enough
13923     test $ac_count -gt 10 && break
13924   done
13925   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
13926 esac
13927 
13928       $ac_path_FGREP_found && break 3
13929     done
13930   done
13931   done
13932 IFS=$as_save_IFS
13933   if test -z "$ac_cv_path_FGREP"; then
13934     as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
13935   fi
13936 else
13937   ac_cv_path_FGREP=$FGREP
13938 fi
13939 
13940    fi
13941 fi
13942 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
13943 $as_echo "$ac_cv_path_FGREP" >&6; }
13944  FGREP="$ac_cv_path_FGREP"
13945 
13946 
13947     else
13948       # If it succeeded, then it was overridden by the user. We will use it
13949       # for the tool.
13950 
13951       # First remove it from the list of overridden variables, so we can test
13952       # for unknown variables in the end.
13953       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13954 
13955       # Check if we try to supply an empty value
13956       if test "x$FGREP" = x; then
13957         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool FGREP= (no value)" >&5
13958 $as_echo "$as_me: Setting user supplied tool FGREP= (no value)" >&6;}
13959         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FGREP" >&5
13960 $as_echo_n "checking for FGREP... " >&6; }
13961         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
13962 $as_echo "disabled" >&6; }
13963       else
13964         # Check if the provided tool contains a complete path.
13965         tool_specified="$FGREP"
13966         tool_basename="${tool_specified##*/}"
13967         if test "x$tool_basename" = "x$tool_specified"; then
13968           # A command without a complete path is provided, search $PATH.
13969           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FGREP=$tool_basename" >&5
13970 $as_echo "$as_me: Will search for user supplied tool FGREP=$tool_basename" >&6;}
13971           # Extract the first word of "$tool_basename", so it can be a program name with args.
13972 set dummy $tool_basename; ac_word=$2
13973 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13974 $as_echo_n "checking for $ac_word... " >&6; }
13975 if ${ac_cv_path_FGREP+:} false; then :
13976   $as_echo_n "(cached) " >&6
13977 else
13978   case $FGREP in
13979   [\\/]* | ?:[\\/]*)
13980   ac_cv_path_FGREP="$FGREP" # Let the user override the test with a path.
13981   ;;
13982   *)
13983   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13984 for as_dir in $PATH
13985 do
13986   IFS=$as_save_IFS
13987   test -z "$as_dir" && as_dir=.
13988     for ac_exec_ext in '' $ac_executable_extensions; do
13989   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13990     ac_cv_path_FGREP="$as_dir/$ac_word$ac_exec_ext"
13991     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13992     break 2
13993   fi
13994 done
13995   done
13996 IFS=$as_save_IFS
13997 
13998   ;;
13999 esac
14000 fi
14001 FGREP=$ac_cv_path_FGREP
14002 if test -n "$FGREP"; then
14003   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FGREP" >&5
14004 $as_echo "$FGREP" >&6; }
14005 else
14006   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14007 $as_echo "no" >&6; }
14008 fi
14009 
14010 
14011           if test "x$FGREP" = x; then
14012             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
14013           fi
14014         else
14015           # Otherwise we believe it is a complete path. Use it as it is.
14016           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FGREP=$tool_specified" >&5
14017 $as_echo "$as_me: Will use user supplied tool FGREP=$tool_specified" >&6;}
14018           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FGREP" >&5
14019 $as_echo_n "checking for FGREP... " >&6; }
14020           if test ! -x "$tool_specified"; then
14021             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
14022 $as_echo "not found" >&6; }
14023             as_fn_error $? "User supplied tool FGREP=$tool_specified does not exist or is not executable" "$LINENO" 5
14024           fi
14025           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
14026 $as_echo "$tool_specified" >&6; }
14027         fi
14028       fi
14029     fi
14030 
14031   fi
14032 
14033 
14034   if test "x$FGREP" = x; then
14035     as_fn_error $? "Could not find required tool for FGREP" "$LINENO" 5
14036   fi
14037 
14038 
14039 
14040 
14041   # Publish this variable in the help.
14042 
14043 
14044   if [ -z "${SED+x}" ]; then
14045     # The variable is not set by user, try to locate tool using the code snippet
14046     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
14047 $as_echo_n "checking for a sed that does not truncate output... " >&6; }
14048 if ${ac_cv_path_SED+:} false; then :
14049   $as_echo_n "(cached) " >&6
14050 else
14051             ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
14052      for ac_i in 1 2 3 4 5 6 7; do
14053        ac_script="$ac_script$as_nl$ac_script"
14054      done
14055      echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
14056      { ac_script=; unset ac_script;}
14057      if test -z "$SED"; then
14058   ac_path_SED_found=false
14059   # Loop through the user's path and test for each of PROGNAME-LIST
14060   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14061 for as_dir in $PATH
14062 do
14063   IFS=$as_save_IFS
14064   test -z "$as_dir" && as_dir=.
14065     for ac_prog in sed gsed; do
14066     for ac_exec_ext in '' $ac_executable_extensions; do
14067       ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
14068       as_fn_executable_p "$ac_path_SED" || continue
14069 # Check for GNU ac_path_SED and select it if it is found.
14070   # Check for GNU $ac_path_SED
14071 case `"$ac_path_SED" --version 2>&1` in
14072 *GNU*)
14073   ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
14074 *)
14075   ac_count=0
14076   $as_echo_n 0123456789 >"conftest.in"
14077   while :
14078   do
14079     cat "conftest.in" "conftest.in" >"conftest.tmp"
14080     mv "conftest.tmp" "conftest.in"
14081     cp "conftest.in" "conftest.nl"
14082     $as_echo '' >> "conftest.nl"
14083     "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
14084     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
14085     as_fn_arith $ac_count + 1 && ac_count=$as_val
14086     if test $ac_count -gt ${ac_path_SED_max-0}; then
14087       # Best one so far, save it but keep looking for a better one
14088       ac_cv_path_SED="$ac_path_SED"
14089       ac_path_SED_max=$ac_count
14090     fi
14091     # 10*(2^10) chars as input seems more than enough
14092     test $ac_count -gt 10 && break
14093   done
14094   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
14095 esac
14096 
14097       $ac_path_SED_found && break 3
14098     done
14099   done
14100   done
14101 IFS=$as_save_IFS
14102   if test -z "$ac_cv_path_SED"; then
14103     as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
14104   fi
14105 else
14106   ac_cv_path_SED=$SED
14107 fi
14108 
14109 fi
14110 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
14111 $as_echo "$ac_cv_path_SED" >&6; }
14112  SED="$ac_cv_path_SED"
14113   rm -f conftest.sed
14114 
14115   else
14116     # The variable is set, but is it from the command line or the environment?
14117 
14118     # Try to remove the string !SED! from our list.
14119     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SED!/}
14120     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
14121       # If it failed, the variable was not from the command line. Ignore it,
14122       # but warn the user (except for BASH, which is always set by the calling BASH).
14123       if test "xSED" != xBASH; then
14124         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SED from the environment. Use command line variables instead." >&5
14125 $as_echo "$as_me: WARNING: Ignoring value of SED from the environment. Use command line variables instead." >&2;}
14126       fi
14127       # Try to locate tool using the code snippet
14128       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
14129 $as_echo_n "checking for a sed that does not truncate output... " >&6; }
14130 if ${ac_cv_path_SED+:} false; then :
14131   $as_echo_n "(cached) " >&6
14132 else
14133             ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
14134      for ac_i in 1 2 3 4 5 6 7; do
14135        ac_script="$ac_script$as_nl$ac_script"
14136      done
14137      echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
14138      { ac_script=; unset ac_script;}
14139      if test -z "$SED"; then
14140   ac_path_SED_found=false
14141   # Loop through the user's path and test for each of PROGNAME-LIST
14142   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14143 for as_dir in $PATH
14144 do
14145   IFS=$as_save_IFS
14146   test -z "$as_dir" && as_dir=.
14147     for ac_prog in sed gsed; do
14148     for ac_exec_ext in '' $ac_executable_extensions; do
14149       ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
14150       as_fn_executable_p "$ac_path_SED" || continue
14151 # Check for GNU ac_path_SED and select it if it is found.
14152   # Check for GNU $ac_path_SED
14153 case `"$ac_path_SED" --version 2>&1` in
14154 *GNU*)
14155   ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
14156 *)
14157   ac_count=0
14158   $as_echo_n 0123456789 >"conftest.in"
14159   while :
14160   do
14161     cat "conftest.in" "conftest.in" >"conftest.tmp"
14162     mv "conftest.tmp" "conftest.in"
14163     cp "conftest.in" "conftest.nl"
14164     $as_echo '' >> "conftest.nl"
14165     "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
14166     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
14167     as_fn_arith $ac_count + 1 && ac_count=$as_val
14168     if test $ac_count -gt ${ac_path_SED_max-0}; then
14169       # Best one so far, save it but keep looking for a better one
14170       ac_cv_path_SED="$ac_path_SED"
14171       ac_path_SED_max=$ac_count
14172     fi
14173     # 10*(2^10) chars as input seems more than enough
14174     test $ac_count -gt 10 && break
14175   done
14176   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
14177 esac
14178 
14179       $ac_path_SED_found && break 3
14180     done
14181   done
14182   done
14183 IFS=$as_save_IFS
14184   if test -z "$ac_cv_path_SED"; then
14185     as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
14186   fi
14187 else
14188   ac_cv_path_SED=$SED
14189 fi
14190 
14191 fi
14192 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
14193 $as_echo "$ac_cv_path_SED" >&6; }
14194  SED="$ac_cv_path_SED"
14195   rm -f conftest.sed
14196 
14197     else
14198       # If it succeeded, then it was overridden by the user. We will use it
14199       # for the tool.
14200 
14201       # First remove it from the list of overridden variables, so we can test
14202       # for unknown variables in the end.
14203       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
14204 
14205       # Check if we try to supply an empty value
14206       if test "x$SED" = x; then
14207         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool SED= (no value)" >&5
14208 $as_echo "$as_me: Setting user supplied tool SED= (no value)" >&6;}
14209         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SED" >&5
14210 $as_echo_n "checking for SED... " >&6; }
14211         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
14212 $as_echo "disabled" >&6; }
14213       else
14214         # Check if the provided tool contains a complete path.
14215         tool_specified="$SED"
14216         tool_basename="${tool_specified##*/}"
14217         if test "x$tool_basename" = "x$tool_specified"; then
14218           # A command without a complete path is provided, search $PATH.
14219           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SED=$tool_basename" >&5
14220 $as_echo "$as_me: Will search for user supplied tool SED=$tool_basename" >&6;}
14221           # Extract the first word of "$tool_basename", so it can be a program name with args.
14222 set dummy $tool_basename; ac_word=$2
14223 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14224 $as_echo_n "checking for $ac_word... " >&6; }
14225 if ${ac_cv_path_SED+:} false; then :
14226   $as_echo_n "(cached) " >&6
14227 else
14228   case $SED in
14229   [\\/]* | ?:[\\/]*)
14230   ac_cv_path_SED="$SED" # Let the user override the test with a path.
14231   ;;
14232   *)
14233   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14234 for as_dir in $PATH
14235 do
14236   IFS=$as_save_IFS
14237   test -z "$as_dir" && as_dir=.
14238     for ac_exec_ext in '' $ac_executable_extensions; do
14239   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14240     ac_cv_path_SED="$as_dir/$ac_word$ac_exec_ext"
14241     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14242     break 2
14243   fi
14244 done
14245   done
14246 IFS=$as_save_IFS
14247 
14248   ;;
14249 esac
14250 fi
14251 SED=$ac_cv_path_SED
14252 if test -n "$SED"; then
14253   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SED" >&5
14254 $as_echo "$SED" >&6; }
14255 else
14256   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14257 $as_echo "no" >&6; }
14258 fi
14259 
14260 
14261           if test "x$SED" = x; then
14262             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
14263           fi
14264         else
14265           # Otherwise we believe it is a complete path. Use it as it is.
14266           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SED=$tool_specified" >&5
14267 $as_echo "$as_me: Will use user supplied tool SED=$tool_specified" >&6;}
14268           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SED" >&5
14269 $as_echo_n "checking for SED... " >&6; }
14270           if test ! -x "$tool_specified"; then
14271             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
14272 $as_echo "not found" >&6; }
14273             as_fn_error $? "User supplied tool SED=$tool_specified does not exist or is not executable" "$LINENO" 5
14274           fi
14275           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
14276 $as_echo "$tool_specified" >&6; }
14277         fi
14278       fi
14279     fi
14280 
14281   fi
14282 
14283 
14284   if test "x$SED" = x; then
14285     as_fn_error $? "Could not find required tool for SED" "$LINENO" 5
14286   fi
14287 
14288 
14289 
14290   # Always force rm.
14291   RM="$RM -f"
14292 
14293   # pwd behaves differently on various platforms and some don't support the -L flag.
14294   # Always use the bash builtin pwd to get uniform behavior.
14295   THEPWDCMD=pwd
14296 
14297   # These are not required on all platforms
14298 
14299 
14300   # Publish this variable in the help.
14301 
14302 
14303   if [ -z "${CYGPATH+x}" ]; then
14304     # The variable is not set by user, try to locate tool using the code snippet
14305     for ac_prog in cygpath
14306 do
14307   # Extract the first word of "$ac_prog", so it can be a program name with args.
14308 set dummy $ac_prog; ac_word=$2
14309 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14310 $as_echo_n "checking for $ac_word... " >&6; }
14311 if ${ac_cv_path_CYGPATH+:} false; then :
14312   $as_echo_n "(cached) " >&6
14313 else
14314   case $CYGPATH in
14315   [\\/]* | ?:[\\/]*)
14316   ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
14317   ;;
14318   *)
14319   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14320 for as_dir in $PATH
14321 do
14322   IFS=$as_save_IFS
14323   test -z "$as_dir" && as_dir=.
14324     for ac_exec_ext in '' $ac_executable_extensions; do
14325   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14326     ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
14327     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14328     break 2
14329   fi
14330 done
14331   done
14332 IFS=$as_save_IFS
14333 
14334   ;;
14335 esac
14336 fi
14337 CYGPATH=$ac_cv_path_CYGPATH
14338 if test -n "$CYGPATH"; then
14339   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
14340 $as_echo "$CYGPATH" >&6; }
14341 else
14342   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14343 $as_echo "no" >&6; }
14344 fi
14345 
14346 
14347   test -n "$CYGPATH" && break
14348 done
14349 
14350   else
14351     # The variable is set, but is it from the command line or the environment?
14352 
14353     # Try to remove the string !CYGPATH! from our list.
14354     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CYGPATH!/}
14355     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
14356       # If it failed, the variable was not from the command line. Ignore it,
14357       # but warn the user (except for BASH, which is always set by the calling BASH).
14358       if test "xCYGPATH" != xBASH; then
14359         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CYGPATH from the environment. Use command line variables instead." >&5
14360 $as_echo "$as_me: WARNING: Ignoring value of CYGPATH from the environment. Use command line variables instead." >&2;}
14361       fi
14362       # Try to locate tool using the code snippet
14363       for ac_prog in cygpath
14364 do
14365   # Extract the first word of "$ac_prog", so it can be a program name with args.
14366 set dummy $ac_prog; ac_word=$2
14367 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14368 $as_echo_n "checking for $ac_word... " >&6; }
14369 if ${ac_cv_path_CYGPATH+:} false; then :
14370   $as_echo_n "(cached) " >&6
14371 else
14372   case $CYGPATH in
14373   [\\/]* | ?:[\\/]*)
14374   ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
14375   ;;
14376   *)
14377   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14378 for as_dir in $PATH
14379 do
14380   IFS=$as_save_IFS
14381   test -z "$as_dir" && as_dir=.
14382     for ac_exec_ext in '' $ac_executable_extensions; do
14383   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14384     ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
14385     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14386     break 2
14387   fi
14388 done
14389   done
14390 IFS=$as_save_IFS
14391 
14392   ;;
14393 esac
14394 fi
14395 CYGPATH=$ac_cv_path_CYGPATH
14396 if test -n "$CYGPATH"; then
14397   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
14398 $as_echo "$CYGPATH" >&6; }
14399 else
14400   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14401 $as_echo "no" >&6; }
14402 fi
14403 
14404 
14405   test -n "$CYGPATH" && break
14406 done
14407 
14408     else
14409       # If it succeeded, then it was overridden by the user. We will use it
14410       # for the tool.
14411 
14412       # First remove it from the list of overridden variables, so we can test
14413       # for unknown variables in the end.
14414       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
14415 
14416       # Check if we try to supply an empty value
14417       if test "x$CYGPATH" = x; then
14418         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CYGPATH= (no value)" >&5
14419 $as_echo "$as_me: Setting user supplied tool CYGPATH= (no value)" >&6;}
14420         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CYGPATH" >&5
14421 $as_echo_n "checking for CYGPATH... " >&6; }
14422         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
14423 $as_echo "disabled" >&6; }
14424       else
14425         # Check if the provided tool contains a complete path.
14426         tool_specified="$CYGPATH"
14427         tool_basename="${tool_specified##*/}"
14428         if test "x$tool_basename" = "x$tool_specified"; then
14429           # A command without a complete path is provided, search $PATH.
14430           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CYGPATH=$tool_basename" >&5
14431 $as_echo "$as_me: Will search for user supplied tool CYGPATH=$tool_basename" >&6;}
14432           # Extract the first word of "$tool_basename", so it can be a program name with args.
14433 set dummy $tool_basename; ac_word=$2
14434 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14435 $as_echo_n "checking for $ac_word... " >&6; }
14436 if ${ac_cv_path_CYGPATH+:} false; then :
14437   $as_echo_n "(cached) " >&6
14438 else
14439   case $CYGPATH in
14440   [\\/]* | ?:[\\/]*)
14441   ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
14442   ;;
14443   *)
14444   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14445 for as_dir in $PATH
14446 do
14447   IFS=$as_save_IFS
14448   test -z "$as_dir" && as_dir=.
14449     for ac_exec_ext in '' $ac_executable_extensions; do
14450   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14451     ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
14452     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14453     break 2
14454   fi
14455 done
14456   done
14457 IFS=$as_save_IFS
14458 
14459   ;;
14460 esac
14461 fi
14462 CYGPATH=$ac_cv_path_CYGPATH
14463 if test -n "$CYGPATH"; then
14464   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
14465 $as_echo "$CYGPATH" >&6; }
14466 else
14467   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14468 $as_echo "no" >&6; }
14469 fi
14470 
14471 
14472           if test "x$CYGPATH" = x; then
14473             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
14474           fi
14475         else
14476           # Otherwise we believe it is a complete path. Use it as it is.
14477           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CYGPATH=$tool_specified" >&5
14478 $as_echo "$as_me: Will use user supplied tool CYGPATH=$tool_specified" >&6;}
14479           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CYGPATH" >&5
14480 $as_echo_n "checking for CYGPATH... " >&6; }
14481           if test ! -x "$tool_specified"; then
14482             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
14483 $as_echo "not found" >&6; }
14484             as_fn_error $? "User supplied tool CYGPATH=$tool_specified does not exist or is not executable" "$LINENO" 5
14485           fi
14486           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
14487 $as_echo "$tool_specified" >&6; }
14488         fi
14489       fi
14490     fi
14491 
14492   fi
14493 
14494 
14495 
14496 
14497   # Publish this variable in the help.
14498 
14499 
14500   if [ -z "${READLINK+x}" ]; then
14501     # The variable is not set by user, try to locate tool using the code snippet
14502     for ac_prog in greadlink readlink
14503 do
14504   # Extract the first word of "$ac_prog", so it can be a program name with args.
14505 set dummy $ac_prog; ac_word=$2
14506 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14507 $as_echo_n "checking for $ac_word... " >&6; }
14508 if ${ac_cv_path_READLINK+:} false; then :
14509   $as_echo_n "(cached) " >&6
14510 else
14511   case $READLINK in
14512   [\\/]* | ?:[\\/]*)
14513   ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
14514   ;;
14515   *)
14516   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14517 for as_dir in $PATH
14518 do
14519   IFS=$as_save_IFS
14520   test -z "$as_dir" && as_dir=.
14521     for ac_exec_ext in '' $ac_executable_extensions; do
14522   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14523     ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
14524     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14525     break 2
14526   fi
14527 done
14528   done
14529 IFS=$as_save_IFS
14530 
14531   ;;
14532 esac
14533 fi
14534 READLINK=$ac_cv_path_READLINK
14535 if test -n "$READLINK"; then
14536   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
14537 $as_echo "$READLINK" >&6; }
14538 else
14539   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14540 $as_echo "no" >&6; }
14541 fi
14542 
14543 
14544   test -n "$READLINK" && break
14545 done
14546 
14547   else
14548     # The variable is set, but is it from the command line or the environment?
14549 
14550     # Try to remove the string !READLINK! from our list.
14551     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!READLINK!/}
14552     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
14553       # If it failed, the variable was not from the command line. Ignore it,
14554       # but warn the user (except for BASH, which is always set by the calling BASH).
14555       if test "xREADLINK" != xBASH; then
14556         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of READLINK from the environment. Use command line variables instead." >&5
14557 $as_echo "$as_me: WARNING: Ignoring value of READLINK from the environment. Use command line variables instead." >&2;}
14558       fi
14559       # Try to locate tool using the code snippet
14560       for ac_prog in greadlink readlink
14561 do
14562   # Extract the first word of "$ac_prog", so it can be a program name with args.
14563 set dummy $ac_prog; ac_word=$2
14564 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14565 $as_echo_n "checking for $ac_word... " >&6; }
14566 if ${ac_cv_path_READLINK+:} false; then :
14567   $as_echo_n "(cached) " >&6
14568 else
14569   case $READLINK in
14570   [\\/]* | ?:[\\/]*)
14571   ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
14572   ;;
14573   *)
14574   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14575 for as_dir in $PATH
14576 do
14577   IFS=$as_save_IFS
14578   test -z "$as_dir" && as_dir=.
14579     for ac_exec_ext in '' $ac_executable_extensions; do
14580   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14581     ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
14582     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14583     break 2
14584   fi
14585 done
14586   done
14587 IFS=$as_save_IFS
14588 
14589   ;;
14590 esac
14591 fi
14592 READLINK=$ac_cv_path_READLINK
14593 if test -n "$READLINK"; then
14594   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
14595 $as_echo "$READLINK" >&6; }
14596 else
14597   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14598 $as_echo "no" >&6; }
14599 fi
14600 
14601 
14602   test -n "$READLINK" && break
14603 done
14604 
14605     else
14606       # If it succeeded, then it was overridden by the user. We will use it
14607       # for the tool.
14608 
14609       # First remove it from the list of overridden variables, so we can test
14610       # for unknown variables in the end.
14611       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
14612 
14613       # Check if we try to supply an empty value
14614       if test "x$READLINK" = x; then
14615         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool READLINK= (no value)" >&5
14616 $as_echo "$as_me: Setting user supplied tool READLINK= (no value)" >&6;}
14617         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READLINK" >&5
14618 $as_echo_n "checking for READLINK... " >&6; }
14619         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
14620 $as_echo "disabled" >&6; }
14621       else
14622         # Check if the provided tool contains a complete path.
14623         tool_specified="$READLINK"
14624         tool_basename="${tool_specified##*/}"
14625         if test "x$tool_basename" = "x$tool_specified"; then
14626           # A command without a complete path is provided, search $PATH.
14627           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool READLINK=$tool_basename" >&5
14628 $as_echo "$as_me: Will search for user supplied tool READLINK=$tool_basename" >&6;}
14629           # Extract the first word of "$tool_basename", so it can be a program name with args.
14630 set dummy $tool_basename; ac_word=$2
14631 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14632 $as_echo_n "checking for $ac_word... " >&6; }
14633 if ${ac_cv_path_READLINK+:} false; then :
14634   $as_echo_n "(cached) " >&6
14635 else
14636   case $READLINK in
14637   [\\/]* | ?:[\\/]*)
14638   ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
14639   ;;
14640   *)
14641   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14642 for as_dir in $PATH
14643 do
14644   IFS=$as_save_IFS
14645   test -z "$as_dir" && as_dir=.
14646     for ac_exec_ext in '' $ac_executable_extensions; do
14647   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14648     ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
14649     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14650     break 2
14651   fi
14652 done
14653   done
14654 IFS=$as_save_IFS
14655 
14656   ;;
14657 esac
14658 fi
14659 READLINK=$ac_cv_path_READLINK
14660 if test -n "$READLINK"; then
14661   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
14662 $as_echo "$READLINK" >&6; }
14663 else
14664   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14665 $as_echo "no" >&6; }
14666 fi
14667 
14668 
14669           if test "x$READLINK" = x; then
14670             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
14671           fi
14672         else
14673           # Otherwise we believe it is a complete path. Use it as it is.
14674           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool READLINK=$tool_specified" >&5
14675 $as_echo "$as_me: Will use user supplied tool READLINK=$tool_specified" >&6;}
14676           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READLINK" >&5
14677 $as_echo_n "checking for READLINK... " >&6; }
14678           if test ! -x "$tool_specified"; then
14679             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
14680 $as_echo "not found" >&6; }
14681             as_fn_error $? "User supplied tool READLINK=$tool_specified does not exist or is not executable" "$LINENO" 5
14682           fi
14683           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
14684 $as_echo "$tool_specified" >&6; }
14685         fi
14686       fi
14687     fi
14688 
14689   fi
14690 
14691 
14692 
14693 
14694   # Publish this variable in the help.
14695 
14696 
14697   if [ -z "${DF+x}" ]; then
14698     # The variable is not set by user, try to locate tool using the code snippet
14699     for ac_prog in df
14700 do
14701   # Extract the first word of "$ac_prog", so it can be a program name with args.
14702 set dummy $ac_prog; ac_word=$2
14703 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14704 $as_echo_n "checking for $ac_word... " >&6; }
14705 if ${ac_cv_path_DF+:} false; then :
14706   $as_echo_n "(cached) " >&6
14707 else
14708   case $DF in
14709   [\\/]* | ?:[\\/]*)
14710   ac_cv_path_DF="$DF" # Let the user override the test with a path.
14711   ;;
14712   *)
14713   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14714 for as_dir in $PATH
14715 do
14716   IFS=$as_save_IFS
14717   test -z "$as_dir" && as_dir=.
14718     for ac_exec_ext in '' $ac_executable_extensions; do
14719   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14720     ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
14721     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14722     break 2
14723   fi
14724 done
14725   done
14726 IFS=$as_save_IFS
14727 
14728   ;;
14729 esac
14730 fi
14731 DF=$ac_cv_path_DF
14732 if test -n "$DF"; then
14733   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
14734 $as_echo "$DF" >&6; }
14735 else
14736   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14737 $as_echo "no" >&6; }
14738 fi
14739 
14740 
14741   test -n "$DF" && break
14742 done
14743 
14744   else
14745     # The variable is set, but is it from the command line or the environment?
14746 
14747     # Try to remove the string !DF! from our list.
14748     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DF!/}
14749     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
14750       # If it failed, the variable was not from the command line. Ignore it,
14751       # but warn the user (except for BASH, which is always set by the calling BASH).
14752       if test "xDF" != xBASH; then
14753         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DF from the environment. Use command line variables instead." >&5
14754 $as_echo "$as_me: WARNING: Ignoring value of DF from the environment. Use command line variables instead." >&2;}
14755       fi
14756       # Try to locate tool using the code snippet
14757       for ac_prog in df
14758 do
14759   # Extract the first word of "$ac_prog", so it can be a program name with args.
14760 set dummy $ac_prog; ac_word=$2
14761 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14762 $as_echo_n "checking for $ac_word... " >&6; }
14763 if ${ac_cv_path_DF+:} false; then :
14764   $as_echo_n "(cached) " >&6
14765 else
14766   case $DF in
14767   [\\/]* | ?:[\\/]*)
14768   ac_cv_path_DF="$DF" # Let the user override the test with a path.
14769   ;;
14770   *)
14771   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14772 for as_dir in $PATH
14773 do
14774   IFS=$as_save_IFS
14775   test -z "$as_dir" && as_dir=.
14776     for ac_exec_ext in '' $ac_executable_extensions; do
14777   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14778     ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
14779     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14780     break 2
14781   fi
14782 done
14783   done
14784 IFS=$as_save_IFS
14785 
14786   ;;
14787 esac
14788 fi
14789 DF=$ac_cv_path_DF
14790 if test -n "$DF"; then
14791   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
14792 $as_echo "$DF" >&6; }
14793 else
14794   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14795 $as_echo "no" >&6; }
14796 fi
14797 
14798 
14799   test -n "$DF" && break
14800 done
14801 
14802     else
14803       # If it succeeded, then it was overridden by the user. We will use it
14804       # for the tool.
14805 
14806       # First remove it from the list of overridden variables, so we can test
14807       # for unknown variables in the end.
14808       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
14809 
14810       # Check if we try to supply an empty value
14811       if test "x$DF" = x; then
14812         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool DF= (no value)" >&5
14813 $as_echo "$as_me: Setting user supplied tool DF= (no value)" >&6;}
14814         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DF" >&5
14815 $as_echo_n "checking for DF... " >&6; }
14816         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
14817 $as_echo "disabled" >&6; }
14818       else
14819         # Check if the provided tool contains a complete path.
14820         tool_specified="$DF"
14821         tool_basename="${tool_specified##*/}"
14822         if test "x$tool_basename" = "x$tool_specified"; then
14823           # A command without a complete path is provided, search $PATH.
14824           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DF=$tool_basename" >&5
14825 $as_echo "$as_me: Will search for user supplied tool DF=$tool_basename" >&6;}
14826           # Extract the first word of "$tool_basename", so it can be a program name with args.
14827 set dummy $tool_basename; ac_word=$2
14828 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14829 $as_echo_n "checking for $ac_word... " >&6; }
14830 if ${ac_cv_path_DF+:} false; then :
14831   $as_echo_n "(cached) " >&6
14832 else
14833   case $DF in
14834   [\\/]* | ?:[\\/]*)
14835   ac_cv_path_DF="$DF" # Let the user override the test with a path.
14836   ;;
14837   *)
14838   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14839 for as_dir in $PATH
14840 do
14841   IFS=$as_save_IFS
14842   test -z "$as_dir" && as_dir=.
14843     for ac_exec_ext in '' $ac_executable_extensions; do
14844   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14845     ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
14846     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14847     break 2
14848   fi
14849 done
14850   done
14851 IFS=$as_save_IFS
14852 
14853   ;;
14854 esac
14855 fi
14856 DF=$ac_cv_path_DF
14857 if test -n "$DF"; then
14858   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
14859 $as_echo "$DF" >&6; }
14860 else
14861   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14862 $as_echo "no" >&6; }
14863 fi
14864 
14865 
14866           if test "x$DF" = x; then
14867             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
14868           fi
14869         else
14870           # Otherwise we believe it is a complete path. Use it as it is.
14871           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DF=$tool_specified" >&5
14872 $as_echo "$as_me: Will use user supplied tool DF=$tool_specified" >&6;}
14873           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DF" >&5
14874 $as_echo_n "checking for DF... " >&6; }
14875           if test ! -x "$tool_specified"; then
14876             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
14877 $as_echo "not found" >&6; }
14878             as_fn_error $? "User supplied tool DF=$tool_specified does not exist or is not executable" "$LINENO" 5
14879           fi
14880           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
14881 $as_echo "$tool_specified" >&6; }
14882         fi
14883       fi
14884     fi
14885 
14886   fi
14887 
14888 
14889 
14890 
14891   # Publish this variable in the help.
14892 
14893 
14894   if [ -z "${CPIO+x}" ]; then
14895     # The variable is not set by user, try to locate tool using the code snippet
14896     for ac_prog in cpio bsdcpio
14897 do
14898   # Extract the first word of "$ac_prog", so it can be a program name with args.
14899 set dummy $ac_prog; ac_word=$2
14900 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14901 $as_echo_n "checking for $ac_word... " >&6; }
14902 if ${ac_cv_path_CPIO+:} false; then :
14903   $as_echo_n "(cached) " >&6
14904 else
14905   case $CPIO in
14906   [\\/]* | ?:[\\/]*)
14907   ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
14908   ;;
14909   *)
14910   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14911 for as_dir in $PATH
14912 do
14913   IFS=$as_save_IFS
14914   test -z "$as_dir" && as_dir=.
14915     for ac_exec_ext in '' $ac_executable_extensions; do
14916   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14917     ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
14918     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14919     break 2
14920   fi
14921 done
14922   done
14923 IFS=$as_save_IFS
14924 
14925   ;;
14926 esac
14927 fi
14928 CPIO=$ac_cv_path_CPIO
14929 if test -n "$CPIO"; then
14930   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
14931 $as_echo "$CPIO" >&6; }
14932 else
14933   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14934 $as_echo "no" >&6; }
14935 fi
14936 
14937 
14938   test -n "$CPIO" && break
14939 done
14940 
14941   else
14942     # The variable is set, but is it from the command line or the environment?
14943 
14944     # Try to remove the string !CPIO! from our list.
14945     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CPIO!/}
14946     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
14947       # If it failed, the variable was not from the command line. Ignore it,
14948       # but warn the user (except for BASH, which is always set by the calling BASH).
14949       if test "xCPIO" != xBASH; then
14950         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CPIO from the environment. Use command line variables instead." >&5
14951 $as_echo "$as_me: WARNING: Ignoring value of CPIO from the environment. Use command line variables instead." >&2;}
14952       fi
14953       # Try to locate tool using the code snippet
14954       for ac_prog in cpio bsdcpio
14955 do
14956   # Extract the first word of "$ac_prog", so it can be a program name with args.
14957 set dummy $ac_prog; ac_word=$2
14958 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14959 $as_echo_n "checking for $ac_word... " >&6; }
14960 if ${ac_cv_path_CPIO+:} false; then :
14961   $as_echo_n "(cached) " >&6
14962 else
14963   case $CPIO in
14964   [\\/]* | ?:[\\/]*)
14965   ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
14966   ;;
14967   *)
14968   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14969 for as_dir in $PATH
14970 do
14971   IFS=$as_save_IFS
14972   test -z "$as_dir" && as_dir=.
14973     for ac_exec_ext in '' $ac_executable_extensions; do
14974   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14975     ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
14976     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14977     break 2
14978   fi
14979 done
14980   done
14981 IFS=$as_save_IFS
14982 
14983   ;;
14984 esac
14985 fi
14986 CPIO=$ac_cv_path_CPIO
14987 if test -n "$CPIO"; then
14988   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
14989 $as_echo "$CPIO" >&6; }
14990 else
14991   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14992 $as_echo "no" >&6; }
14993 fi
14994 
14995 
14996   test -n "$CPIO" && break
14997 done
14998 
14999     else
15000       # If it succeeded, then it was overridden by the user. We will use it
15001       # for the tool.
15002 
15003       # First remove it from the list of overridden variables, so we can test
15004       # for unknown variables in the end.
15005       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
15006 
15007       # Check if we try to supply an empty value
15008       if test "x$CPIO" = x; then
15009         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CPIO= (no value)" >&5
15010 $as_echo "$as_me: Setting user supplied tool CPIO= (no value)" >&6;}
15011         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CPIO" >&5
15012 $as_echo_n "checking for CPIO... " >&6; }
15013         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
15014 $as_echo "disabled" >&6; }
15015       else
15016         # Check if the provided tool contains a complete path.
15017         tool_specified="$CPIO"
15018         tool_basename="${tool_specified##*/}"
15019         if test "x$tool_basename" = "x$tool_specified"; then
15020           # A command without a complete path is provided, search $PATH.
15021           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CPIO=$tool_basename" >&5
15022 $as_echo "$as_me: Will search for user supplied tool CPIO=$tool_basename" >&6;}
15023           # Extract the first word of "$tool_basename", so it can be a program name with args.
15024 set dummy $tool_basename; ac_word=$2
15025 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
15026 $as_echo_n "checking for $ac_word... " >&6; }
15027 if ${ac_cv_path_CPIO+:} false; then :
15028   $as_echo_n "(cached) " >&6
15029 else
15030   case $CPIO in
15031   [\\/]* | ?:[\\/]*)
15032   ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
15033   ;;
15034   *)
15035   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
15036 for as_dir in $PATH
15037 do
15038   IFS=$as_save_IFS
15039   test -z "$as_dir" && as_dir=.
15040     for ac_exec_ext in '' $ac_executable_extensions; do
15041   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
15042     ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
15043     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
15044     break 2
15045   fi
15046 done
15047   done
15048 IFS=$as_save_IFS
15049 
15050   ;;
15051 esac
15052 fi
15053 CPIO=$ac_cv_path_CPIO
15054 if test -n "$CPIO"; then
15055   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
15056 $as_echo "$CPIO" >&6; }
15057 else
15058   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
15059 $as_echo "no" >&6; }
15060 fi
15061 
15062 
15063           if test "x$CPIO" = x; then
15064             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
15065           fi
15066         else
15067           # Otherwise we believe it is a complete path. Use it as it is.
15068           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CPIO=$tool_specified" >&5
15069 $as_echo "$as_me: Will use user supplied tool CPIO=$tool_specified" >&6;}
15070           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CPIO" >&5
15071 $as_echo_n "checking for CPIO... " >&6; }
15072           if test ! -x "$tool_specified"; then
15073             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
15074 $as_echo "not found" >&6; }
15075             as_fn_error $? "User supplied tool CPIO=$tool_specified does not exist or is not executable" "$LINENO" 5
15076           fi
15077           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
15078 $as_echo "$tool_specified" >&6; }
15079         fi
15080       fi
15081     fi
15082 
15083   fi
15084 
15085 
15086 
15087 
15088   # Publish this variable in the help.
15089 
15090 
15091   if [ -z "${NICE+x}" ]; then
15092     # The variable is not set by user, try to locate tool using the code snippet
15093     for ac_prog in nice
15094 do
15095   # Extract the first word of "$ac_prog", so it can be a program name with args.
15096 set dummy $ac_prog; ac_word=$2
15097 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
15098 $as_echo_n "checking for $ac_word... " >&6; }
15099 if ${ac_cv_path_NICE+:} false; then :
15100   $as_echo_n "(cached) " >&6
15101 else
15102   case $NICE in
15103   [\\/]* | ?:[\\/]*)
15104   ac_cv_path_NICE="$NICE" # Let the user override the test with a path.
15105   ;;
15106   *)
15107   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
15108 for as_dir in $PATH
15109 do
15110   IFS=$as_save_IFS
15111   test -z "$as_dir" && as_dir=.
15112     for ac_exec_ext in '' $ac_executable_extensions; do
15113   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
15114     ac_cv_path_NICE="$as_dir/$ac_word$ac_exec_ext"
15115     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
15116     break 2
15117   fi
15118 done
15119   done
15120 IFS=$as_save_IFS
15121 
15122   ;;
15123 esac
15124 fi
15125 NICE=$ac_cv_path_NICE
15126 if test -n "$NICE"; then
15127   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NICE" >&5
15128 $as_echo "$NICE" >&6; }
15129 else
15130   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
15131 $as_echo "no" >&6; }
15132 fi
15133 
15134 
15135   test -n "$NICE" && break
15136 done
15137 
15138   else
15139     # The variable is set, but is it from the command line or the environment?
15140 
15141     # Try to remove the string !NICE! from our list.
15142     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!NICE!/}
15143     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
15144       # If it failed, the variable was not from the command line. Ignore it,
15145       # but warn the user (except for BASH, which is always set by the calling BASH).
15146       if test "xNICE" != xBASH; then
15147         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of NICE from the environment. Use command line variables instead." >&5
15148 $as_echo "$as_me: WARNING: Ignoring value of NICE from the environment. Use command line variables instead." >&2;}
15149       fi
15150       # Try to locate tool using the code snippet
15151       for ac_prog in nice
15152 do
15153   # Extract the first word of "$ac_prog", so it can be a program name with args.
15154 set dummy $ac_prog; ac_word=$2
15155 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
15156 $as_echo_n "checking for $ac_word... " >&6; }
15157 if ${ac_cv_path_NICE+:} false; then :
15158   $as_echo_n "(cached) " >&6
15159 else
15160   case $NICE in
15161   [\\/]* | ?:[\\/]*)
15162   ac_cv_path_NICE="$NICE" # Let the user override the test with a path.
15163   ;;
15164   *)
15165   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
15166 for as_dir in $PATH
15167 do
15168   IFS=$as_save_IFS
15169   test -z "$as_dir" && as_dir=.
15170     for ac_exec_ext in '' $ac_executable_extensions; do
15171   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
15172     ac_cv_path_NICE="$as_dir/$ac_word$ac_exec_ext"
15173     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
15174     break 2
15175   fi
15176 done
15177   done
15178 IFS=$as_save_IFS
15179 
15180   ;;
15181 esac
15182 fi
15183 NICE=$ac_cv_path_NICE
15184 if test -n "$NICE"; then
15185   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NICE" >&5
15186 $as_echo "$NICE" >&6; }
15187 else
15188   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
15189 $as_echo "no" >&6; }
15190 fi
15191 
15192 
15193   test -n "$NICE" && break
15194 done
15195 
15196     else
15197       # If it succeeded, then it was overridden by the user. We will use it
15198       # for the tool.
15199 
15200       # First remove it from the list of overridden variables, so we can test
15201       # for unknown variables in the end.
15202       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
15203 
15204       # Check if we try to supply an empty value
15205       if test "x$NICE" = x; then
15206         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool NICE= (no value)" >&5
15207 $as_echo "$as_me: Setting user supplied tool NICE= (no value)" >&6;}
15208         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NICE" >&5
15209 $as_echo_n "checking for NICE... " >&6; }
15210         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
15211 $as_echo "disabled" >&6; }
15212       else
15213         # Check if the provided tool contains a complete path.
15214         tool_specified="$NICE"
15215         tool_basename="${tool_specified##*/}"
15216         if test "x$tool_basename" = "x$tool_specified"; then
15217           # A command without a complete path is provided, search $PATH.
15218           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool NICE=$tool_basename" >&5
15219 $as_echo "$as_me: Will search for user supplied tool NICE=$tool_basename" >&6;}
15220           # Extract the first word of "$tool_basename", so it can be a program name with args.
15221 set dummy $tool_basename; ac_word=$2
15222 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
15223 $as_echo_n "checking for $ac_word... " >&6; }
15224 if ${ac_cv_path_NICE+:} false; then :
15225   $as_echo_n "(cached) " >&6
15226 else
15227   case $NICE in
15228   [\\/]* | ?:[\\/]*)
15229   ac_cv_path_NICE="$NICE" # Let the user override the test with a path.
15230   ;;
15231   *)
15232   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
15233 for as_dir in $PATH
15234 do
15235   IFS=$as_save_IFS
15236   test -z "$as_dir" && as_dir=.
15237     for ac_exec_ext in '' $ac_executable_extensions; do
15238   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
15239     ac_cv_path_NICE="$as_dir/$ac_word$ac_exec_ext"
15240     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
15241     break 2
15242   fi
15243 done
15244   done
15245 IFS=$as_save_IFS
15246 
15247   ;;
15248 esac
15249 fi
15250 NICE=$ac_cv_path_NICE
15251 if test -n "$NICE"; then
15252   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NICE" >&5
15253 $as_echo "$NICE" >&6; }
15254 else
15255   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
15256 $as_echo "no" >&6; }
15257 fi
15258 
15259 
15260           if test "x$NICE" = x; then
15261             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
15262           fi
15263         else
15264           # Otherwise we believe it is a complete path. Use it as it is.
15265           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool NICE=$tool_specified" >&5
15266 $as_echo "$as_me: Will use user supplied tool NICE=$tool_specified" >&6;}
15267           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NICE" >&5
15268 $as_echo_n "checking for NICE... " >&6; }
15269           if test ! -x "$tool_specified"; then
15270             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
15271 $as_echo "not found" >&6; }
15272             as_fn_error $? "User supplied tool NICE=$tool_specified does not exist or is not executable" "$LINENO" 5
15273           fi
15274           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
15275 $as_echo "$tool_specified" >&6; }
15276         fi
15277       fi
15278     fi
15279 
15280   fi
15281 
15282 
15283 
15284 
15285 # Now we can determine OpenJDK build and target platforms. This is required to
15286 # have early on.
15287 # Make sure we can run config.sub.
15288 $SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
15289   as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5
15290 
15291 { $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
15292 $as_echo_n "checking build system type... " >&6; }
15293 if ${ac_cv_build+:} false; then :
15294   $as_echo_n "(cached) " >&6
15295 else
15296   ac_build_alias=$build_alias
15297 test "x$ac_build_alias" = x &&
15298   ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
15299 test "x$ac_build_alias" = x &&
15300   as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5
15301 ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
15302   as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5
15303 
15304 fi
15305 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
15306 $as_echo "$ac_cv_build" >&6; }
15307 case $ac_cv_build in
15308 *-*-*) ;;
15309 *) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;;
15310 esac
15311 build=$ac_cv_build
15312 ac_save_IFS=$IFS; IFS='-'
15313 set x $ac_cv_build
15314 shift
15315 build_cpu=$1
15316 build_vendor=$2
15317 shift; shift
15318 # Remember, the first character of IFS is used to create $*,
15319 # except with old shells:
15320 build_os=$*
15321 IFS=$ac_save_IFS
15322 case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
15323 
15324 
15325 { $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
15326 $as_echo_n "checking host system type... " >&6; }
15327 if ${ac_cv_host+:} false; then :
15328   $as_echo_n "(cached) " >&6
15329 else
15330   if test "x$host_alias" = x; then
15331   ac_cv_host=$ac_cv_build
15332 else
15333   ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
15334     as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5
15335 fi
15336 
15337 fi
15338 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
15339 $as_echo "$ac_cv_host" >&6; }
15340 case $ac_cv_host in
15341 *-*-*) ;;
15342 *) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;;
15343 esac
15344 host=$ac_cv_host
15345 ac_save_IFS=$IFS; IFS='-'
15346 set x $ac_cv_host
15347 shift
15348 host_cpu=$1
15349 host_vendor=$2
15350 shift; shift
15351 # Remember, the first character of IFS is used to create $*,
15352 # except with old shells:
15353 host_os=$*
15354 IFS=$ac_save_IFS
15355 case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
15356 
15357 
15358 { $as_echo "$as_me:${as_lineno-$LINENO}: checking target system type" >&5
15359 $as_echo_n "checking target system type... " >&6; }
15360 if ${ac_cv_target+:} false; then :
15361   $as_echo_n "(cached) " >&6
15362 else
15363   if test "x$target_alias" = x; then
15364   ac_cv_target=$ac_cv_host
15365 else
15366   ac_cv_target=`$SHELL "$ac_aux_dir/config.sub" $target_alias` ||
15367     as_fn_error $? "$SHELL $ac_aux_dir/config.sub $target_alias failed" "$LINENO" 5
15368 fi
15369 
15370 fi
15371 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_target" >&5
15372 $as_echo "$ac_cv_target" >&6; }
15373 case $ac_cv_target in
15374 *-*-*) ;;
15375 *) as_fn_error $? "invalid value of canonical target" "$LINENO" 5;;
15376 esac
15377 target=$ac_cv_target
15378 ac_save_IFS=$IFS; IFS='-'
15379 set x $ac_cv_target
15380 shift
15381 target_cpu=$1
15382 target_vendor=$2
15383 shift; shift
15384 # Remember, the first character of IFS is used to create $*,
15385 # except with old shells:
15386 target_os=$*
15387 IFS=$ac_save_IFS
15388 case $target_os in *\ *) target_os=`echo "$target_os" | sed 's/ /-/g'`;; esac
15389 
15390 
15391 # The aliases save the names the user supplied, while $host etc.
15392 # will get canonicalized.
15393 test -n "$target_alias" &&
15394   test "$program_prefix$program_suffix$program_transform_name" = \
15395     NONENONEs,x,x, &&
15396   program_prefix=${target_alias}-
15397 
15398   # Figure out the build and target systems. # Note that in autoconf terminology, "build" is obvious, but "target"
15399   # is confusing; it assumes you are cross-compiling a cross-compiler (!)  and "target" is thus the target of the
15400   # product you're building. The target of this build is called "host". Since this is confusing to most people, we
15401   # have not adopted that system, but use "target" as the platform we are building for. In some places though we need
15402   # to use the configure naming style.
15403 
15404 
15405 
15406 
15407 
15408   # Copy the autoconf trip/quadruplet verbatim to OPENJDK_TARGET_AUTOCONF_NAME
15409   # (from the autoconf "host") and OPENJDK_BUILD_AUTOCONF_NAME
15410   # Note that we might later on rewrite e.g. OPENJDK_TARGET_CPU due to reduced build,
15411   # but this will not change the value of OPENJDK_TARGET_AUTOCONF_NAME.
15412   OPENJDK_TARGET_AUTOCONF_NAME="$host"
15413   OPENJDK_BUILD_AUTOCONF_NAME="$build"
15414 
15415 
15416 
15417   # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
15418 
15419   case "$build_os" in
15420     *linux*)
15421       VAR_OS=linux
15422       VAR_OS_TYPE=unix
15423       ;;
15424     *solaris*)
15425       VAR_OS=solaris
15426       VAR_OS_TYPE=unix
15427       ;;
15428     *darwin*)
15429       VAR_OS=macosx
15430       VAR_OS_TYPE=unix
15431       ;;
15432     *bsd*)
15433       VAR_OS=bsd
15434       VAR_OS_TYPE=unix
15435       ;;
15436     *cygwin*)
15437       VAR_OS=windows
15438       VAR_OS_ENV=windows.cygwin
15439       ;;
15440     *mingw*)
15441       VAR_OS=windows
15442       VAR_OS_ENV=windows.msys
15443       ;;
15444     *aix*)
15445       VAR_OS=aix
15446       VAR_OS_TYPE=unix
15447       ;;
15448     *)
15449       as_fn_error $? "unsupported operating system $build_os" "$LINENO" 5
15450       ;;
15451   esac
15452 
15453 
15454   # First argument is the cpu name from the trip/quad
15455   case "$build_cpu" in
15456     x86_64)
15457       VAR_CPU=x86_64
15458       VAR_CPU_ARCH=x86
15459       VAR_CPU_BITS=64
15460       VAR_CPU_ENDIAN=little
15461       ;;
15462     i?86)
15463       VAR_CPU=x86
15464       VAR_CPU_ARCH=x86
15465       VAR_CPU_BITS=32
15466       VAR_CPU_ENDIAN=little
15467       ;;
15468     arm*)
15469       VAR_CPU=arm
15470       VAR_CPU_ARCH=arm
15471       VAR_CPU_BITS=32
15472       VAR_CPU_ENDIAN=little
15473       ;;
15474     aarch64)
15475       VAR_CPU=aarch64
15476       VAR_CPU_ARCH=aarch64
15477       VAR_CPU_BITS=64
15478       VAR_CPU_ENDIAN=little
15479       ;;
15480     powerpc)
15481       VAR_CPU=ppc
15482       VAR_CPU_ARCH=ppc
15483       VAR_CPU_BITS=32
15484       VAR_CPU_ENDIAN=big
15485       ;;
15486     powerpc64)
15487       VAR_CPU=ppc64
15488       VAR_CPU_ARCH=ppc
15489       VAR_CPU_BITS=64
15490       VAR_CPU_ENDIAN=big
15491       ;;
15492     powerpc64le)
15493       VAR_CPU=ppc64le
15494       VAR_CPU_ARCH=ppc
15495       VAR_CPU_BITS=64
15496       VAR_CPU_ENDIAN=little
15497       ;;
15498     s390)
15499       VAR_CPU=s390
15500       VAR_CPU_ARCH=s390
15501       VAR_CPU_BITS=32
15502       VAR_CPU_ENDIAN=big
15503       ;;
15504     s390x)
15505       VAR_CPU=s390x
15506       VAR_CPU_ARCH=s390
15507       VAR_CPU_BITS=64
15508       VAR_CPU_ENDIAN=big
15509       ;;
15510     sparc)
15511       VAR_CPU=sparc
15512       VAR_CPU_ARCH=sparc
15513       VAR_CPU_BITS=32
15514       VAR_CPU_ENDIAN=big
15515       ;;
15516     sparcv9|sparc64)
15517       VAR_CPU=sparcv9
15518       VAR_CPU_ARCH=sparc
15519       VAR_CPU_BITS=64
15520       VAR_CPU_ENDIAN=big
15521       ;;
15522     *)
15523       as_fn_error $? "unsupported cpu $build_cpu" "$LINENO" 5
15524       ;;
15525   esac
15526 
15527   # ..and setup our own variables. (Do this explicitely to facilitate searching)
15528   OPENJDK_BUILD_OS="$VAR_OS"
15529   if test "x$VAR_OS_TYPE" != x; then
15530     OPENJDK_BUILD_OS_TYPE="$VAR_OS_TYPE"
15531   else
15532     OPENJDK_BUILD_OS_TYPE="$VAR_OS"
15533   fi
15534   if test "x$VAR_OS_ENV" != x; then
15535     OPENJDK_BUILD_OS_ENV="$VAR_OS_ENV"
15536   else
15537     OPENJDK_BUILD_OS_ENV="$VAR_OS"
15538   fi
15539   OPENJDK_BUILD_CPU="$VAR_CPU"
15540   OPENJDK_BUILD_CPU_ARCH="$VAR_CPU_ARCH"
15541   OPENJDK_BUILD_CPU_BITS="$VAR_CPU_BITS"
15542   OPENJDK_BUILD_CPU_ENDIAN="$VAR_CPU_ENDIAN"
15543 
15544 
15545 
15546 
15547 
15548 
15549 
15550 
15551   { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-build os-cpu" >&5
15552 $as_echo_n "checking openjdk-build os-cpu... " >&6; }
15553   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&5
15554 $as_echo "$OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&6; }
15555 
15556   # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
15557 
15558   case "$host_os" in
15559     *linux*)
15560       VAR_OS=linux
15561       VAR_OS_TYPE=unix
15562       ;;
15563     *solaris*)
15564       VAR_OS=solaris
15565       VAR_OS_TYPE=unix
15566       ;;
15567     *darwin*)
15568       VAR_OS=macosx
15569       VAR_OS_TYPE=unix
15570       ;;
15571     *bsd*)
15572       VAR_OS=bsd
15573       VAR_OS_TYPE=unix
15574       ;;
15575     *cygwin*)
15576       VAR_OS=windows
15577       VAR_OS_ENV=windows.cygwin
15578       ;;
15579     *mingw*)
15580       VAR_OS=windows
15581       VAR_OS_ENV=windows.msys
15582       ;;
15583     *aix*)
15584       VAR_OS=aix
15585       VAR_OS_TYPE=unix
15586       ;;
15587     *)
15588       as_fn_error $? "unsupported operating system $host_os" "$LINENO" 5
15589       ;;
15590   esac
15591 
15592 
15593   # First argument is the cpu name from the trip/quad
15594   case "$host_cpu" in
15595     x86_64)
15596       VAR_CPU=x86_64
15597       VAR_CPU_ARCH=x86
15598       VAR_CPU_BITS=64
15599       VAR_CPU_ENDIAN=little
15600       ;;
15601     i?86)
15602       VAR_CPU=x86
15603       VAR_CPU_ARCH=x86
15604       VAR_CPU_BITS=32
15605       VAR_CPU_ENDIAN=little
15606       ;;
15607     arm*)
15608       VAR_CPU=arm
15609       VAR_CPU_ARCH=arm
15610       VAR_CPU_BITS=32
15611       VAR_CPU_ENDIAN=little
15612       ;;
15613     aarch64)
15614       VAR_CPU=aarch64
15615       VAR_CPU_ARCH=aarch64
15616       VAR_CPU_BITS=64
15617       VAR_CPU_ENDIAN=little
15618       ;;
15619     powerpc)
15620       VAR_CPU=ppc
15621       VAR_CPU_ARCH=ppc
15622       VAR_CPU_BITS=32
15623       VAR_CPU_ENDIAN=big
15624       ;;
15625     powerpc64)
15626       VAR_CPU=ppc64
15627       VAR_CPU_ARCH=ppc
15628       VAR_CPU_BITS=64
15629       VAR_CPU_ENDIAN=big
15630       ;;
15631     powerpc64le)
15632       VAR_CPU=ppc64le
15633       VAR_CPU_ARCH=ppc
15634       VAR_CPU_BITS=64
15635       VAR_CPU_ENDIAN=little
15636       ;;
15637     s390)
15638       VAR_CPU=s390
15639       VAR_CPU_ARCH=s390
15640       VAR_CPU_BITS=32
15641       VAR_CPU_ENDIAN=big
15642       ;;
15643     s390x)
15644       VAR_CPU=s390x
15645       VAR_CPU_ARCH=s390
15646       VAR_CPU_BITS=64
15647       VAR_CPU_ENDIAN=big
15648       ;;
15649     sparc)
15650       VAR_CPU=sparc
15651       VAR_CPU_ARCH=sparc
15652       VAR_CPU_BITS=32
15653       VAR_CPU_ENDIAN=big
15654       ;;
15655     sparcv9|sparc64)
15656       VAR_CPU=sparcv9
15657       VAR_CPU_ARCH=sparc
15658       VAR_CPU_BITS=64
15659       VAR_CPU_ENDIAN=big
15660       ;;
15661     *)
15662       as_fn_error $? "unsupported cpu $host_cpu" "$LINENO" 5
15663       ;;
15664   esac
15665 
15666   # ... and setup our own variables. (Do this explicitely to facilitate searching)
15667   OPENJDK_TARGET_OS="$VAR_OS"
15668   if test "x$VAR_OS_TYPE" != x; then
15669     OPENJDK_TARGET_OS_TYPE="$VAR_OS_TYPE"
15670   else
15671     OPENJDK_TARGET_OS_TYPE="$VAR_OS"
15672   fi
15673   if test "x$VAR_OS_ENV" != x; then
15674     OPENJDK_TARGET_OS_ENV="$VAR_OS_ENV"
15675   else
15676     OPENJDK_TARGET_OS_ENV="$VAR_OS"
15677   fi
15678   OPENJDK_TARGET_CPU="$VAR_CPU"
15679   OPENJDK_TARGET_CPU_ARCH="$VAR_CPU_ARCH"
15680   OPENJDK_TARGET_CPU_BITS="$VAR_CPU_BITS"
15681   OPENJDK_TARGET_CPU_ENDIAN="$VAR_CPU_ENDIAN"
15682 
15683 
15684 
15685 
15686 
15687 
15688 
15689 
15690   { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-target os-cpu" >&5
15691 $as_echo_n "checking openjdk-target os-cpu... " >&6; }
15692   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&5
15693 $as_echo "$OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&6; }
15694 
15695 
15696 
15697 # Check whether --with-target-bits was given.
15698 if test "${with_target_bits+set}" = set; then :
15699   withval=$with_target_bits;
15700 fi
15701 
15702 
15703   # We have three types of compiles:
15704   # native  == normal compilation, target system == build system
15705   # cross   == traditional cross compilation, target system != build system; special toolchain needed
15706   # reduced == using native compilers, but with special flags (e.g. -m32) to produce 32-bit builds on 64-bit machines
15707   #
15708   if test "x$OPENJDK_BUILD_AUTOCONF_NAME" != "x$OPENJDK_TARGET_AUTOCONF_NAME"; then
15709     # We're doing a proper cross-compilation
15710     COMPILE_TYPE="cross"
15711   else
15712     COMPILE_TYPE="native"
15713   fi
15714 
15715   if test "x$with_target_bits" != x; then
15716     if test "x$COMPILE_TYPE" = "xcross"; then
15717       as_fn_error $? "It is not possible to combine --with-target-bits=X and proper cross-compilation. Choose either." "$LINENO" 5
15718     fi
15719 
15720     if test "x$with_target_bits" = x32 && test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
15721       # A reduced build is requested
15722       COMPILE_TYPE="reduced"
15723       OPENJDK_TARGET_CPU_BITS=32
15724       if test "x$OPENJDK_TARGET_CPU_ARCH" = "xx86"; then
15725         OPENJDK_TARGET_CPU=x86
15726       elif test "x$OPENJDK_TARGET_CPU_ARCH" = "xsparc"; then
15727         OPENJDK_TARGET_CPU=sparc
15728       else
15729         as_fn_error $? "Reduced build (--with-target-bits=32) is only supported on x86_64 and sparcv9" "$LINENO" 5
15730       fi
15731     elif test "x$with_target_bits" = x64 && test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
15732       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
15733     elif test "x$with_target_bits" = "x$OPENJDK_TARGET_CPU_BITS"; then
15734       { $as_echo "$as_me:${as_lineno-$LINENO}: --with-target-bits are set to build platform address size; argument has no meaning" >&5
15735 $as_echo "$as_me: --with-target-bits are set to build platform address size; argument has no meaning" >&6;}
15736     else
15737       as_fn_error $? "--with-target-bits can only be 32 or 64, you specified $with_target_bits!" "$LINENO" 5
15738     fi
15739   fi
15740 
15741 
15742   { $as_echo "$as_me:${as_lineno-$LINENO}: checking compilation type" >&5
15743 $as_echo_n "checking compilation type... " >&6; }
15744   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMPILE_TYPE" >&5
15745 $as_echo "$COMPILE_TYPE" >&6; }
15746 
15747 
15748   if test "x$OPENJDK_TARGET_OS" = "xsolaris"; then
15749     REQUIRED_OS_NAME=SunOS
15750     REQUIRED_OS_VERSION=5.10
15751   fi
15752   if test "x$OPENJDK_TARGET_OS" = "xlinux"; then
15753     REQUIRED_OS_NAME=Linux
15754     REQUIRED_OS_VERSION=2.6
15755   fi
15756   if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
15757     REQUIRED_OS_NAME=Windows
15758     if test "x$OPENJDK_TARGET_CPU_BITS" = "x64"; then
15759       REQUIRED_OS_VERSION=5.2
15760     else
15761       REQUIRED_OS_VERSION=5.1
15762     fi
15763   fi
15764   if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
15765     REQUIRED_OS_NAME=Darwin
15766     REQUIRED_OS_VERSION=11.2
15767   fi
15768   if test "x$OPENJDK_TARGET_OS" = "xaix"; then
15769     REQUIRED_OS_NAME=AIX
15770     REQUIRED_OS_VERSION=7.1
15771   fi
15772 
15773 
15774 
15775 
15776 
15777 
15778   # Also store the legacy naming of the cpu.
15779   # Ie i586 and amd64 instead of x86 and x86_64
15780   OPENJDK_TARGET_CPU_LEGACY="$OPENJDK_TARGET_CPU"
15781   if test "x$OPENJDK_TARGET_CPU" = xx86; then
15782     OPENJDK_TARGET_CPU_LEGACY="i586"
15783   elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
15784     # On all platforms except MacOSX replace x86_64 with amd64.
15785     OPENJDK_TARGET_CPU_LEGACY="amd64"
15786   fi
15787 
15788 
15789   # And the second legacy naming of the cpu.
15790   # Ie i386 and amd64 instead of x86 and x86_64.
15791   OPENJDK_TARGET_CPU_LEGACY_LIB="$OPENJDK_TARGET_CPU"
15792   if test "x$OPENJDK_TARGET_CPU" = xx86; then
15793     OPENJDK_TARGET_CPU_LEGACY_LIB="i386"
15794   elif test "x$OPENJDK_TARGET_CPU" = xx86_64; then
15795     OPENJDK_TARGET_CPU_LEGACY_LIB="amd64"
15796   fi
15797 
15798 
15799   # This is the name of the cpu (but using i386 and amd64 instead of
15800   # x86 and x86_64, respectively), preceeded by a /, to be used when
15801   # locating libraries. On macosx, it's empty, though.
15802   OPENJDK_TARGET_CPU_LIBDIR="/$OPENJDK_TARGET_CPU_LEGACY_LIB"
15803   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
15804     OPENJDK_TARGET_CPU_LIBDIR=""
15805   fi
15806 
15807 
15808   # OPENJDK_TARGET_CPU_ISADIR is normally empty. On 64-bit Solaris systems, it is set to
15809   # /amd64 or /sparcv9. This string is appended to some library paths, like this:
15810   # /usr/lib${OPENJDK_TARGET_CPU_ISADIR}/libexample.so
15811   OPENJDK_TARGET_CPU_ISADIR=""
15812   if test "x$OPENJDK_TARGET_OS" = xsolaris; then
15813     if test "x$OPENJDK_TARGET_CPU" = xx86_64; then
15814       OPENJDK_TARGET_CPU_ISADIR="/amd64"
15815     elif test "x$OPENJDK_TARGET_CPU" = xsparcv9; then
15816       OPENJDK_TARGET_CPU_ISADIR="/sparcv9"
15817     fi
15818   fi
15819 
15820 
15821   # Setup OPENJDK_TARGET_CPU_OSARCH, which is used to set the os.arch Java system property
15822   OPENJDK_TARGET_CPU_OSARCH="$OPENJDK_TARGET_CPU"
15823   if test "x$OPENJDK_TARGET_OS" = xlinux && test "x$OPENJDK_TARGET_CPU" = xx86; then
15824     # On linux only, we replace x86 with i386.
15825     OPENJDK_TARGET_CPU_OSARCH="i386"
15826   elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
15827     # On all platforms except macosx, we replace x86_64 with amd64.
15828     OPENJDK_TARGET_CPU_OSARCH="amd64"
15829   fi
15830 
15831 
15832   OPENJDK_TARGET_CPU_JLI="$OPENJDK_TARGET_CPU"
15833   if test "x$OPENJDK_TARGET_CPU" = xx86; then
15834     OPENJDK_TARGET_CPU_JLI="i386"
15835   elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
15836     # On all platforms except macosx, we replace x86_64 with amd64.
15837     OPENJDK_TARGET_CPU_JLI="amd64"
15838   fi
15839   # Now setup the -D flags for building libjli.
15840   OPENJDK_TARGET_CPU_JLI_CFLAGS="-DLIBARCHNAME='\"$OPENJDK_TARGET_CPU_JLI\"'"
15841   if test "x$OPENJDK_TARGET_OS" = xsolaris; then
15842     if test "x$OPENJDK_TARGET_CPU_ARCH" = xsparc; then
15843       OPENJDK_TARGET_CPU_JLI_CFLAGS="$OPENJDK_TARGET_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"sparc\"' -DLIBARCH64NAME='\"sparcv9\"'"
15844     elif test "x$OPENJDK_TARGET_CPU_ARCH" = xx86; then
15845       OPENJDK_TARGET_CPU_JLI_CFLAGS="$OPENJDK_TARGET_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"i386\"' -DLIBARCH64NAME='\"amd64\"'"
15846     fi
15847   fi
15848 
15849 
15850   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
15851       OPENJDK_TARGET_OS_EXPORT_DIR=macosx
15852   else
15853       OPENJDK_TARGET_OS_EXPORT_DIR=${OPENJDK_TARGET_OS_TYPE}
15854   fi
15855 
15856 
15857   # The new version string in JDK 9 also defined new naming of OS and ARCH for bundles
15858   # Macosx is osx and x86_64 is x64
15859   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
15860     OPENJDK_TARGET_OS_BUNDLE="osx"
15861   else
15862     OPENJDK_TARGET_OS_BUNDLE="$OPENJDK_TARGET_OS"
15863   fi
15864   if test "x$OPENJDK_TARGET_CPU" = xx86_64; then
15865     OPENJDK_TARGET_CPU_BUNDLE="x64"
15866   else
15867     OPENJDK_TARGET_CPU_BUNDLE="$OPENJDK_TARGET_CPU"
15868   fi
15869   OPENJDK_TARGET_BUNDLE_PLATFORM="${OPENJDK_TARGET_OS_BUNDLE}-${OPENJDK_TARGET_CPU_BUNDLE}"
15870 
15871 
15872 
15873 
15874   if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
15875     A_LP64="LP64:="
15876     # -D_LP64=1 is only set on linux and mac. Setting on windows causes diff in
15877     # unpack200.exe
15878     if test "x$OPENJDK_TARGET_OS" = xlinux || test "x$OPENJDK_TARGET_OS" = xmacosx; then
15879       OPENJDK_TARGET_ADD_LP64="-D_LP64=1"
15880     fi
15881   fi
15882   LP64=$A_LP64
15883 
15884 
15885   if test "x$COMPILE_TYPE" = "xcross"; then
15886     # FIXME: ... or should this include reduced builds..?
15887     DEFINE_CROSS_COMPILE_ARCH="CROSS_COMPILE_ARCH:=$OPENJDK_TARGET_CPU_LEGACY"
15888   else
15889     DEFINE_CROSS_COMPILE_ARCH=""
15890   fi
15891 
15892 
15893   # Convert openjdk platform names to hotspot names
15894 
15895   HOTSPOT_TARGET_OS=${OPENJDK_TARGET_OS}
15896   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
15897     HOTSPOT_TARGET_OS=bsd
15898   fi
15899 
15900 
15901   HOTSPOT_TARGET_OS_TYPE=${OPENJDK_TARGET_OS_TYPE}
15902   if test "x$OPENJDK_TARGET_OS_TYPE" = xunix; then
15903     HOTSPOT_TARGET_OS_TYPE=posix
15904   fi
15905 
15906 
15907   HOTSPOT_TARGET_CPU=${OPENJDK_TARGET_CPU}
15908   if test "x$OPENJDK_TARGET_CPU" = xx86; then
15909     HOTSPOT_TARGET_CPU=x86_32
15910   elif test "x$OPENJDK_TARGET_CPU" = xsparcv9; then
15911     HOTSPOT_TARGET_CPU=sparc
15912   elif test "x$OPENJDK_TARGET_CPU" = xppc64; then
15913     HOTSPOT_TARGET_CPU=ppc_64
15914   elif test "x$OPENJDK_TARGET_CPU" = xppc64le; then
15915     HOTSPOT_TARGET_CPU=ppc_64
15916   fi
15917 
15918 
15919   # This is identical with OPENJDK_*, but define anyway for consistency.
15920   HOTSPOT_TARGET_CPU_ARCH=${OPENJDK_TARGET_CPU_ARCH}
15921 
15922 
15923   # Setup HOTSPOT_TARGET_CPU_DEFINE
15924   if test "x$OPENJDK_TARGET_CPU" = xx86; then
15925     HOTSPOT_TARGET_CPU_DEFINE=IA32
15926   elif test "x$OPENJDK_TARGET_CPU" = xx86_64; then
15927     HOTSPOT_TARGET_CPU_DEFINE=AMD64
15928   elif test "x$OPENJDK_TARGET_CPU" = xsparcv9; then
15929     HOTSPOT_TARGET_CPU_DEFINE=SPARC
15930   elif test "x$OPENJDK_TARGET_CPU" = xaarch64; then
15931     HOTSPOT_TARGET_CPU_DEFINE=AARCH64
15932   elif test "x$OPENJDK_TARGET_CPU" = xppc64; then
15933     HOTSPOT_TARGET_CPU_DEFINE=PPC64
15934   elif test "x$OPENJDK_TARGET_CPU" = xppc64le; then
15935     HOTSPOT_TARGET_CPU_DEFINE=PPC64
15936 
15937   # The cpu defines below are for zero, we don't support them directly.
15938   elif test "x$OPENJDK_TARGET_CPU" = xsparc; then
15939     HOTSPOT_TARGET_CPU_DEFINE=SPARC
15940   elif test "x$OPENJDK_TARGET_CPU" = xppc; then
15941     HOTSPOT_TARGET_CPU_DEFINE=PPC32
15942   elif test "x$OPENJDK_TARGET_CPU" = xs390; then
15943     HOTSPOT_TARGET_CPU_DEFINE=S390
15944   elif test "x$OPENJDK_TARGET_CPU" = xs390x; then
15945     HOTSPOT_TARGET_CPU_DEFINE=S390
15946   fi
15947 
15948 
15949 
15950 
15951   # Also store the legacy naming of the cpu.
15952   # Ie i586 and amd64 instead of x86 and x86_64
15953   OPENJDK_BUILD_CPU_LEGACY="$OPENJDK_BUILD_CPU"
15954   if test "x$OPENJDK_BUILD_CPU" = xx86; then
15955     OPENJDK_BUILD_CPU_LEGACY="i586"
15956   elif test "x$OPENJDK_BUILD_OS" != xmacosx && test "x$OPENJDK_BUILD_CPU" = xx86_64; then
15957     # On all platforms except MacOSX replace x86_64 with amd64.
15958     OPENJDK_BUILD_CPU_LEGACY="amd64"
15959   fi
15960 
15961 
15962   # And the second legacy naming of the cpu.
15963   # Ie i386 and amd64 instead of x86 and x86_64.
15964   OPENJDK_BUILD_CPU_LEGACY_LIB="$OPENJDK_BUILD_CPU"
15965   if test "x$OPENJDK_BUILD_CPU" = xx86; then
15966     OPENJDK_BUILD_CPU_LEGACY_LIB="i386"
15967   elif test "x$OPENJDK_BUILD_CPU" = xx86_64; then
15968     OPENJDK_BUILD_CPU_LEGACY_LIB="amd64"
15969   fi
15970 
15971 
15972   # This is the name of the cpu (but using i386 and amd64 instead of
15973   # x86 and x86_64, respectively), preceeded by a /, to be used when
15974   # locating libraries. On macosx, it's empty, though.
15975   OPENJDK_BUILD_CPU_LIBDIR="/$OPENJDK_BUILD_CPU_LEGACY_LIB"
15976   if test "x$OPENJDK_BUILD_OS" = xmacosx; then
15977     OPENJDK_BUILD_CPU_LIBDIR=""
15978   fi
15979 
15980 
15981   # OPENJDK_BUILD_CPU_ISADIR is normally empty. On 64-bit Solaris systems, it is set to
15982   # /amd64 or /sparcv9. This string is appended to some library paths, like this:
15983   # /usr/lib${OPENJDK_BUILD_CPU_ISADIR}/libexample.so
15984   OPENJDK_BUILD_CPU_ISADIR=""
15985   if test "x$OPENJDK_BUILD_OS" = xsolaris; then
15986     if test "x$OPENJDK_BUILD_CPU" = xx86_64; then
15987       OPENJDK_BUILD_CPU_ISADIR="/amd64"
15988     elif test "x$OPENJDK_BUILD_CPU" = xsparcv9; then
15989       OPENJDK_BUILD_CPU_ISADIR="/sparcv9"
15990     fi
15991   fi
15992 
15993 
15994   # Setup OPENJDK_BUILD_CPU_OSARCH, which is used to set the os.arch Java system property
15995   OPENJDK_BUILD_CPU_OSARCH="$OPENJDK_BUILD_CPU"
15996   if test "x$OPENJDK_BUILD_OS" = xlinux && test "x$OPENJDK_BUILD_CPU" = xx86; then
15997     # On linux only, we replace x86 with i386.
15998     OPENJDK_BUILD_CPU_OSARCH="i386"
15999   elif test "x$OPENJDK_BUILD_OS" != xmacosx && test "x$OPENJDK_BUILD_CPU" = xx86_64; then
16000     # On all platforms except macosx, we replace x86_64 with amd64.
16001     OPENJDK_BUILD_CPU_OSARCH="amd64"
16002   fi
16003 
16004 
16005   OPENJDK_BUILD_CPU_JLI="$OPENJDK_BUILD_CPU"
16006   if test "x$OPENJDK_BUILD_CPU" = xx86; then
16007     OPENJDK_BUILD_CPU_JLI="i386"
16008   elif test "x$OPENJDK_BUILD_OS" != xmacosx && test "x$OPENJDK_BUILD_CPU" = xx86_64; then
16009     # On all platforms except macosx, we replace x86_64 with amd64.
16010     OPENJDK_BUILD_CPU_JLI="amd64"
16011   fi
16012   # Now setup the -D flags for building libjli.
16013   OPENJDK_BUILD_CPU_JLI_CFLAGS="-DLIBARCHNAME='\"$OPENJDK_BUILD_CPU_JLI\"'"
16014   if test "x$OPENJDK_BUILD_OS" = xsolaris; then
16015     if test "x$OPENJDK_BUILD_CPU_ARCH" = xsparc; then
16016       OPENJDK_BUILD_CPU_JLI_CFLAGS="$OPENJDK_BUILD_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"sparc\"' -DLIBARCH64NAME='\"sparcv9\"'"
16017     elif test "x$OPENJDK_BUILD_CPU_ARCH" = xx86; then
16018       OPENJDK_BUILD_CPU_JLI_CFLAGS="$OPENJDK_BUILD_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"i386\"' -DLIBARCH64NAME='\"amd64\"'"
16019     fi
16020   fi
16021 
16022 
16023   if test "x$OPENJDK_BUILD_OS" = xmacosx; then
16024       OPENJDK_BUILD_OS_EXPORT_DIR=macosx
16025   else
16026       OPENJDK_BUILD_OS_EXPORT_DIR=${OPENJDK_BUILD_OS_TYPE}
16027   fi
16028 
16029 
16030   # The new version string in JDK 9 also defined new naming of OS and ARCH for bundles
16031   # Macosx is osx and x86_64 is x64
16032   if test "x$OPENJDK_BUILD_OS" = xmacosx; then
16033     OPENJDK_BUILD_OS_BUNDLE="osx"
16034   else
16035     OPENJDK_BUILD_OS_BUNDLE="$OPENJDK_TARGET_OS"
16036   fi
16037   if test "x$OPENJDK_BUILD_CPU" = xx86_64; then
16038     OPENJDK_BUILD_CPU_BUNDLE="x64"
16039   else
16040     OPENJDK_BUILD_CPU_BUNDLE="$OPENJDK_BUILD_CPU"
16041   fi
16042   OPENJDK_BUILD_BUNDLE_PLATFORM="${OPENJDK_BUILD_OS_BUNDLE}-${OPENJDK_BUILD_CPU_BUNDLE}"
16043 
16044 
16045 
16046 
16047   if test "x$OPENJDK_BUILD_CPU_BITS" = x64; then
16048     A_LP64="LP64:="
16049     # -D_LP64=1 is only set on linux and mac. Setting on windows causes diff in
16050     # unpack200.exe
16051     if test "x$OPENJDK_BUILD_OS" = xlinux || test "x$OPENJDK_BUILD_OS" = xmacosx; then
16052       OPENJDK_BUILD_ADD_LP64="-D_LP64=1"
16053     fi
16054   fi
16055   LP64=$A_LP64
16056 
16057 
16058   if test "x$COMPILE_TYPE" = "xcross"; then
16059     # FIXME: ... or should this include reduced builds..?
16060     DEFINE_CROSS_COMPILE_ARCH="CROSS_COMPILE_ARCH:=$OPENJDK_BUILD_CPU_LEGACY"
16061   else
16062     DEFINE_CROSS_COMPILE_ARCH=""
16063   fi
16064 
16065 
16066   # Convert openjdk platform names to hotspot names
16067 
16068   HOTSPOT_BUILD_OS=${OPENJDK_BUILD_OS}
16069   if test "x$OPENJDK_BUILD_OS" = xmacosx; then
16070     HOTSPOT_BUILD_OS=bsd
16071   fi
16072 
16073 
16074   HOTSPOT_BUILD_OS_TYPE=${OPENJDK_BUILD_OS_TYPE}
16075   if test "x$OPENJDK_BUILD_OS_TYPE" = xunix; then
16076     HOTSPOT_BUILD_OS_TYPE=posix
16077   fi
16078 
16079 
16080   HOTSPOT_BUILD_CPU=${OPENJDK_BUILD_CPU}
16081   if test "x$OPENJDK_BUILD_CPU" = xx86; then
16082     HOTSPOT_BUILD_CPU=x86_32
16083   elif test "x$OPENJDK_BUILD_CPU" = xsparcv9; then
16084     HOTSPOT_BUILD_CPU=sparc
16085   elif test "x$OPENJDK_BUILD_CPU" = xppc64; then
16086     HOTSPOT_BUILD_CPU=ppc_64
16087   elif test "x$OPENJDK_BUILD_CPU" = xppc64le; then
16088     HOTSPOT_BUILD_CPU=ppc_64
16089   fi
16090 
16091 
16092   # This is identical with OPENJDK_*, but define anyway for consistency.
16093   HOTSPOT_BUILD_CPU_ARCH=${OPENJDK_BUILD_CPU_ARCH}
16094 
16095 
16096   # Setup HOTSPOT_BUILD_CPU_DEFINE
16097   if test "x$OPENJDK_BUILD_CPU" = xx86; then
16098     HOTSPOT_BUILD_CPU_DEFINE=IA32
16099   elif test "x$OPENJDK_BUILD_CPU" = xx86_64; then
16100     HOTSPOT_BUILD_CPU_DEFINE=AMD64
16101   elif test "x$OPENJDK_BUILD_CPU" = xsparcv9; then
16102     HOTSPOT_BUILD_CPU_DEFINE=SPARC
16103   elif test "x$OPENJDK_BUILD_CPU" = xaarch64; then
16104     HOTSPOT_BUILD_CPU_DEFINE=AARCH64
16105   elif test "x$OPENJDK_BUILD_CPU" = xppc64; then
16106     HOTSPOT_BUILD_CPU_DEFINE=PPC64
16107   elif test "x$OPENJDK_BUILD_CPU" = xppc64le; then
16108     HOTSPOT_BUILD_CPU_DEFINE=PPC64
16109 
16110   # The cpu defines below are for zero, we don't support them directly.
16111   elif test "x$OPENJDK_BUILD_CPU" = xsparc; then
16112     HOTSPOT_BUILD_CPU_DEFINE=SPARC
16113   elif test "x$OPENJDK_BUILD_CPU" = xppc; then
16114     HOTSPOT_BUILD_CPU_DEFINE=PPC32
16115   elif test "x$OPENJDK_BUILD_CPU" = xs390; then
16116     HOTSPOT_BUILD_CPU_DEFINE=S390
16117   elif test "x$OPENJDK_BUILD_CPU" = xs390x; then
16118     HOTSPOT_BUILD_CPU_DEFINE=S390
16119   fi
16120 
16121 
16122 
16123 
16124   # ZERO_ARCHDEF is used to enable architecture-specific code.
16125   # This is used in legacy hotspot build.
16126   ZERO_ARCHDEF="$HOTSPOT_TARGET_CPU_DEFINE"
16127 
16128 
16129 
16130 
16131 
16132 # Continue setting up basic stuff. Most remaining code require fundamental tools.
16133 
16134   # Save the current directory this script was started from
16135   CURDIR="$PWD"
16136 
16137   # We might need to rewrite ORIGINAL_PATH, if it includes "#", to quote them
16138   # for make. We couldn't do this when we retrieved ORIGINAL_PATH, since SED
16139   # was not available at that time.
16140   REWRITTEN_PATH=`$ECHO "$ORIGINAL_PATH" | $SED -e 's/#/\\\\#/g'`
16141   if test "x$REWRITTEN_PATH" != "x$ORIGINAL_PATH"; then
16142     ORIGINAL_PATH="$REWRITTEN_PATH"
16143     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting ORIGINAL_PATH to $REWRITTEN_PATH" >&5
16144 $as_echo "$as_me: Rewriting ORIGINAL_PATH to $REWRITTEN_PATH" >&6;}
16145   fi
16146 
16147   if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
16148     PATH_SEP=";"
16149 
16150   SRC_ROOT_LENGTH=`$THEPWDCMD -L|$WC -m`
16151   if test $SRC_ROOT_LENGTH -gt 100; then
16152     as_fn_error $? "Your base path is too long. It is $SRC_ROOT_LENGTH characters long, but only 100 is supported" "$LINENO" 5
16153   fi
16154 
16155   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16156     { $as_echo "$as_me:${as_lineno-$LINENO}: checking cygwin release" >&5
16157 $as_echo_n "checking cygwin release... " >&6; }
16158     CYGWIN_VERSION=`$UNAME -r`
16159     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_VERSION" >&5
16160 $as_echo "$CYGWIN_VERSION" >&6; }
16161     WINDOWS_ENV_VENDOR='cygwin'
16162     WINDOWS_ENV_VERSION="$CYGWIN_VERSION"
16163 
16164     CYGWIN_VERSION_OLD=`$ECHO $CYGWIN_VERSION | $GREP -e '^1\.0-6'`
16165     if test "x$CYGWIN_VERSION_OLD" != x; then
16166       { $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
16167 $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;}
16168       as_fn_error $? "Cannot continue" "$LINENO" 5
16169     fi
16170     if test "x$CYGPATH" = x; then
16171       as_fn_error $? "Something is wrong with your cygwin installation since I cannot find cygpath.exe in your path" "$LINENO" 5
16172     fi
16173     { $as_echo "$as_me:${as_lineno-$LINENO}: checking cygwin root directory as unix-style path" >&5
16174 $as_echo_n "checking cygwin root directory as unix-style path... " >&6; }
16175     # The cmd output ends with Windows line endings (CR/LF), the grep command will strip that away
16176     cygwin_winpath_root=`cd / ; cmd /c cd | $GREP ".*"`
16177     # Force cygpath to report the proper root by including a trailing space, and then stripping it off again.
16178     CYGWIN_ROOT_PATH=`$CYGPATH -u "$cygwin_winpath_root " | $CUT -f 1 -d " "`
16179     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_ROOT_PATH" >&5
16180 $as_echo "$CYGWIN_ROOT_PATH" >&6; }
16181     WINDOWS_ENV_ROOT_PATH="$CYGWIN_ROOT_PATH"
16182     test_cygdrive_prefix=`$ECHO $CYGWIN_ROOT_PATH | $GREP ^/cygdrive/`
16183     if test "x$test_cygdrive_prefix" = x; then
16184       as_fn_error $? "Your cygdrive prefix is not /cygdrive. This is currently not supported. Change with mount -c." "$LINENO" 5
16185     fi
16186   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16187     { $as_echo "$as_me:${as_lineno-$LINENO}: checking msys release" >&5
16188 $as_echo_n "checking msys release... " >&6; }
16189     MSYS_VERSION=`$UNAME -r`
16190     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSYS_VERSION" >&5
16191 $as_echo "$MSYS_VERSION" >&6; }
16192 
16193     WINDOWS_ENV_VENDOR='msys'
16194     WINDOWS_ENV_VERSION="$MSYS_VERSION"
16195 
16196     { $as_echo "$as_me:${as_lineno-$LINENO}: checking msys root directory as unix-style path" >&5
16197 $as_echo_n "checking msys root directory as unix-style path... " >&6; }
16198     # The cmd output ends with Windows line endings (CR/LF), the grep command will strip that away
16199     MSYS_ROOT_PATH=`cd / ; cmd /c cd | $GREP ".*"`
16200 
16201   windows_path="$MSYS_ROOT_PATH"
16202   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16203     unix_path=`$CYGPATH -u "$windows_path"`
16204     MSYS_ROOT_PATH="$unix_path"
16205   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16206     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16207     MSYS_ROOT_PATH="$unix_path"
16208   fi
16209 
16210     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSYS_ROOT_PATH" >&5
16211 $as_echo "$MSYS_ROOT_PATH" >&6; }
16212     WINDOWS_ENV_ROOT_PATH="$MSYS_ROOT_PATH"
16213   else
16214     as_fn_error $? "Unknown Windows environment. Neither cygwin nor msys was detected." "$LINENO" 5
16215   fi
16216 
16217   # Test if windows or unix (cygwin/msys) find is first in path.
16218   { $as_echo "$as_me:${as_lineno-$LINENO}: checking what kind of 'find' is first on the PATH" >&5
16219 $as_echo_n "checking what kind of 'find' is first on the PATH... " >&6; }
16220   FIND_BINARY_OUTPUT=`find --version 2>&1`
16221   if test "x`echo $FIND_BINARY_OUTPUT | $GREP GNU`" != x; then
16222     { $as_echo "$as_me:${as_lineno-$LINENO}: result: unix style" >&5
16223 $as_echo "unix style" >&6; }
16224   elif test "x`echo $FIND_BINARY_OUTPUT | $GREP FIND`" != x; then
16225     { $as_echo "$as_me:${as_lineno-$LINENO}: result: Windows" >&5
16226 $as_echo "Windows" >&6; }
16227     { $as_echo "$as_me:${as_lineno-$LINENO}: Your path contains Windows tools (C:\Windows\system32) before your unix (cygwin or msys) tools." >&5
16228 $as_echo "$as_me: Your path contains Windows tools (C:\Windows\system32) before your unix (cygwin or msys) tools." >&6;}
16229     { $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
16230 $as_echo "$as_me: This will not work. Please correct and make sure /usr/bin (or similar) is first in path." >&6;}
16231     as_fn_error $? "Cannot continue" "$LINENO" 5
16232   else
16233     { $as_echo "$as_me:${as_lineno-$LINENO}: result: unknown" >&5
16234 $as_echo "unknown" >&6; }
16235     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: It seems that your find utility is non-standard." >&5
16236 $as_echo "$as_me: WARNING: It seems that your find utility is non-standard." >&2;}
16237   fi
16238 
16239   else
16240     PATH_SEP=":"
16241   fi
16242 
16243 
16244   # We get the top-level directory from the supporting wrappers.
16245   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for top-level directory" >&5
16246 $as_echo_n "checking for top-level directory... " >&6; }
16247   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOPDIR" >&5
16248 $as_echo "$TOPDIR" >&6; }
16249 
16250 
16251   # Save the original version of TOPDIR for string comparisons
16252   ORIGINAL_TOPDIR="$TOPDIR"
16253 
16254 
16255   # We can only call BASIC_FIXUP_PATH after BASIC_CHECK_PATHS_WINDOWS.
16256 
16257   # Only process if variable expands to non-empty
16258 
16259   if test "x$CURDIR" != x; then
16260     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16261 
16262   # Input might be given as Windows format, start by converting to
16263   # unix format.
16264   path="$CURDIR"
16265   new_path=`$CYGPATH -u "$path"`
16266 
16267   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
16268   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
16269   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
16270   # "foo.exe" is OK but "foo" is an error.
16271   #
16272   # This test is therefore slightly more accurate than "test -f" to check for file precense.
16273   # It is also a way to make sure we got the proper file name for the real test later on.
16274   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
16275   if test "x$test_shortpath" = x; then
16276     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CURDIR, which resolves as \"$path\", is invalid." >&5
16277 $as_echo "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid." >&6;}
16278     as_fn_error $? "Cannot locate the the path of CURDIR" "$LINENO" 5
16279   fi
16280 
16281   # Call helper function which possibly converts this using DOS-style short mode.
16282   # If so, the updated path is stored in $new_path.
16283 
16284   input_path="$new_path"
16285   # Check if we need to convert this using DOS-style short mode. If the path
16286   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16287   # take no chances and rewrite it.
16288   # Note: m4 eats our [], so we need to use [ and ] instead.
16289   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
16290   if test "x$has_forbidden_chars" != x; then
16291     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16292     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
16293     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
16294     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
16295       # Going to short mode and back again did indeed matter. Since short mode is
16296       # case insensitive, let's make it lowercase to improve readability.
16297       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16298       # Now convert it back to Unix-style (cygpath)
16299       input_path=`$CYGPATH -u "$shortmode_path"`
16300       new_path="$input_path"
16301     fi
16302   fi
16303 
16304   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
16305   if test "x$test_cygdrive_prefix" = x; then
16306     # As a simple fix, exclude /usr/bin since it's not a real path.
16307     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
16308       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
16309       # a path prefixed by /cygdrive for fixpath to work.
16310       new_path="$CYGWIN_ROOT_PATH$input_path"
16311     fi
16312   fi
16313 
16314 
16315   if test "x$path" != "x$new_path"; then
16316     CURDIR="$new_path"
16317     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
16318 $as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
16319   fi
16320 
16321     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16322 
16323   path="$CURDIR"
16324   has_colon=`$ECHO $path | $GREP ^.:`
16325   new_path="$path"
16326   if test "x$has_colon" = x; then
16327     # Not in mixed or Windows style, start by that.
16328     new_path=`cmd //c echo $path`
16329   fi
16330 
16331 
16332   input_path="$new_path"
16333   # Check if we need to convert this using DOS-style short mode. If the path
16334   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16335   # take no chances and rewrite it.
16336   # Note: m4 eats our [], so we need to use [ and ] instead.
16337   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
16338   if test "x$has_forbidden_chars" != x; then
16339     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16340     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16341   fi
16342 
16343 
16344   windows_path="$new_path"
16345   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16346     unix_path=`$CYGPATH -u "$windows_path"`
16347     new_path="$unix_path"
16348   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16349     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16350     new_path="$unix_path"
16351   fi
16352 
16353   if test "x$path" != "x$new_path"; then
16354     CURDIR="$new_path"
16355     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
16356 $as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
16357   fi
16358 
16359   # Save the first 10 bytes of this path to the storage, so fixpath can work.
16360   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
16361 
16362     else
16363       # We're on a unix platform. Hooray! :)
16364       path="$CURDIR"
16365       has_space=`$ECHO "$path" | $GREP " "`
16366       if test "x$has_space" != x; then
16367         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CURDIR, which resolves as \"$path\", is invalid." >&5
16368 $as_echo "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid." >&6;}
16369         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
16370       fi
16371 
16372       # Use eval to expand a potential ~
16373       eval path="$path"
16374       if test ! -f "$path" && test ! -d "$path"; then
16375         as_fn_error $? "The path of CURDIR, which resolves as \"$path\", is not found." "$LINENO" 5
16376       fi
16377 
16378       if test -d "$path"; then
16379         CURDIR="`cd "$path"; $THEPWDCMD -L`"
16380       else
16381         dir="`$DIRNAME "$path"`"
16382         base="`$BASENAME "$path"`"
16383         CURDIR="`cd "$dir"; $THEPWDCMD -L`/$base"
16384       fi
16385     fi
16386   fi
16387 
16388 
16389   # Only process if variable expands to non-empty
16390 
16391   if test "x$TOPDIR" != x; then
16392     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16393 
16394   # Input might be given as Windows format, start by converting to
16395   # unix format.
16396   path="$TOPDIR"
16397   new_path=`$CYGPATH -u "$path"`
16398 
16399   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
16400   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
16401   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
16402   # "foo.exe" is OK but "foo" is an error.
16403   #
16404   # This test is therefore slightly more accurate than "test -f" to check for file precense.
16405   # It is also a way to make sure we got the proper file name for the real test later on.
16406   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
16407   if test "x$test_shortpath" = x; then
16408     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of TOPDIR, which resolves as \"$path\", is invalid." >&5
16409 $as_echo "$as_me: The path of TOPDIR, which resolves as \"$path\", is invalid." >&6;}
16410     as_fn_error $? "Cannot locate the the path of TOPDIR" "$LINENO" 5
16411   fi
16412 
16413   # Call helper function which possibly converts this using DOS-style short mode.
16414   # If so, the updated path is stored in $new_path.
16415 
16416   input_path="$new_path"
16417   # Check if we need to convert this using DOS-style short mode. If the path
16418   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16419   # take no chances and rewrite it.
16420   # Note: m4 eats our [], so we need to use [ and ] instead.
16421   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
16422   if test "x$has_forbidden_chars" != x; then
16423     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16424     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
16425     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
16426     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
16427       # Going to short mode and back again did indeed matter. Since short mode is
16428       # case insensitive, let's make it lowercase to improve readability.
16429       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16430       # Now convert it back to Unix-style (cygpath)
16431       input_path=`$CYGPATH -u "$shortmode_path"`
16432       new_path="$input_path"
16433     fi
16434   fi
16435 
16436   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
16437   if test "x$test_cygdrive_prefix" = x; then
16438     # As a simple fix, exclude /usr/bin since it's not a real path.
16439     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
16440       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
16441       # a path prefixed by /cygdrive for fixpath to work.
16442       new_path="$CYGWIN_ROOT_PATH$input_path"
16443     fi
16444   fi
16445 
16446 
16447   if test "x$path" != "x$new_path"; then
16448     TOPDIR="$new_path"
16449     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting TOPDIR to \"$new_path\"" >&5
16450 $as_echo "$as_me: Rewriting TOPDIR to \"$new_path\"" >&6;}
16451   fi
16452 
16453     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16454 
16455   path="$TOPDIR"
16456   has_colon=`$ECHO $path | $GREP ^.:`
16457   new_path="$path"
16458   if test "x$has_colon" = x; then
16459     # Not in mixed or Windows style, start by that.
16460     new_path=`cmd //c echo $path`
16461   fi
16462 
16463 
16464   input_path="$new_path"
16465   # Check if we need to convert this using DOS-style short mode. If the path
16466   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16467   # take no chances and rewrite it.
16468   # Note: m4 eats our [], so we need to use [ and ] instead.
16469   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
16470   if test "x$has_forbidden_chars" != x; then
16471     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16472     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16473   fi
16474 
16475 
16476   windows_path="$new_path"
16477   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16478     unix_path=`$CYGPATH -u "$windows_path"`
16479     new_path="$unix_path"
16480   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16481     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16482     new_path="$unix_path"
16483   fi
16484 
16485   if test "x$path" != "x$new_path"; then
16486     TOPDIR="$new_path"
16487     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting TOPDIR to \"$new_path\"" >&5
16488 $as_echo "$as_me: Rewriting TOPDIR to \"$new_path\"" >&6;}
16489   fi
16490 
16491   # Save the first 10 bytes of this path to the storage, so fixpath can work.
16492   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
16493 
16494     else
16495       # We're on a unix platform. Hooray! :)
16496       path="$TOPDIR"
16497       has_space=`$ECHO "$path" | $GREP " "`
16498       if test "x$has_space" != x; then
16499         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of TOPDIR, which resolves as \"$path\", is invalid." >&5
16500 $as_echo "$as_me: The path of TOPDIR, which resolves as \"$path\", is invalid." >&6;}
16501         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
16502       fi
16503 
16504       # Use eval to expand a potential ~
16505       eval path="$path"
16506       if test ! -f "$path" && test ! -d "$path"; then
16507         as_fn_error $? "The path of TOPDIR, which resolves as \"$path\", is not found." "$LINENO" 5
16508       fi
16509 
16510       if test -d "$path"; then
16511         TOPDIR="`cd "$path"; $THEPWDCMD -L`"
16512       else
16513         dir="`$DIRNAME "$path"`"
16514         base="`$BASENAME "$path"`"
16515         TOPDIR="`cd "$dir"; $THEPWDCMD -L`/$base"
16516       fi
16517     fi
16518   fi
16519 
16520   # SRC_ROOT is a traditional alias for TOPDIR.
16521   SRC_ROOT=$TOPDIR
16522 
16523   # Calculate a canonical version of TOPDIR for string comparisons
16524   CANONICAL_TOPDIR=$TOPDIR
16525 
16526   if test "x$OPENJDK_BUILD_OS" != xwindows; then
16527     # Follow a chain of symbolic links. Use readlink
16528     # where it exists, else fall back to horribly
16529     # complicated shell code.
16530     if test "x$READLINK_TESTED" != yes; then
16531       # On MacOSX there is a readlink tool with a different
16532       # purpose than the GNU readlink tool. Check the found readlink.
16533       ISGNU=`$READLINK --version 2>&1 | $GREP GNU`
16534       if test "x$ISGNU" = x; then
16535         # A readlink that we do not know how to use.
16536         # Are there other non-GNU readlinks out there?
16537         READLINK_TESTED=yes
16538         READLINK=
16539       fi
16540     fi
16541 
16542     if test "x$READLINK" != x; then
16543       CANONICAL_TOPDIR=`$READLINK -f $CANONICAL_TOPDIR`
16544     else
16545       # Save the current directory for restoring afterwards
16546       STARTDIR=$PWD
16547       COUNTER=0
16548       sym_link_dir=`$DIRNAME $CANONICAL_TOPDIR`
16549       sym_link_file=`$BASENAME $CANONICAL_TOPDIR`
16550       cd $sym_link_dir
16551       # Use -P flag to resolve symlinks in directories.
16552       cd `$THEPWDCMD -P`
16553       sym_link_dir=`$THEPWDCMD -P`
16554       # Resolve file symlinks
16555       while test $COUNTER -lt 20; do
16556         ISLINK=`$LS -l $sym_link_dir/$sym_link_file | $GREP '\->' | $SED -e 's/.*-> \(.*\)/\1/'`
16557         if test "x$ISLINK" == x; then
16558           # This is not a symbolic link! We are done!
16559           break
16560         fi
16561         # Again resolve directory symlinks since the target of the just found
16562         # link could be in a different directory
16563         cd `$DIRNAME $ISLINK`
16564         sym_link_dir=`$THEPWDCMD -P`
16565         sym_link_file=`$BASENAME $ISLINK`
16566         let COUNTER=COUNTER+1
16567       done
16568       cd $STARTDIR
16569       CANONICAL_TOPDIR=$sym_link_dir/$sym_link_file
16570     fi
16571   fi
16572 
16573 
16574 
16575   # Locate the directory of this script.
16576   AUTOCONF_DIR=$TOPDIR/common/autoconf
16577 
16578   # Setup username (for use in adhoc version strings etc)
16579   # Outer [ ] to quote m4.
16580    USERNAME=`$ECHO "$USER" | $TR -d -c '[a-z][A-Z][0-9]'`
16581 
16582 
16583 
16584 # Check if it's a pure open build or if custom sources are to be used.
16585 
16586   # Check whether --enable-openjdk-only was given.
16587 if test "${enable_openjdk_only+set}" = set; then :
16588   enableval=$enable_openjdk_only;
16589 else
16590   enable_openjdk_only="no"
16591 fi
16592 
16593 
16594   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if custom source is suppressed (openjdk-only)" >&5
16595 $as_echo_n "checking if custom source is suppressed (openjdk-only)... " >&6; }
16596   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $enable_openjdk_only" >&5
16597 $as_echo "$enable_openjdk_only" >&6; }
16598   if test "x$enable_openjdk_only" = "xyes"; then
16599     SUPPRESS_CUSTOM_SOURCE="true"
16600   elif test "x$enable_openjdk_only" = "xno"; then
16601     SUPPRESS_CUSTOM_SOURCE="false"
16602   else
16603     as_fn_error $? "Invalid value for --enable-openjdk-only: $enable_openjdk_only" "$LINENO" 5
16604   fi
16605 
16606   # custom-make-dir is deprecated. Please use your custom-hook.m4 to override
16607   # the IncludeCustomExtension macro.
16608 
16609 
16610 # Check whether --with-custom-make-dir was given.
16611 if test "${with_custom_make_dir+set}" = set; then :
16612   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
16613 $as_echo "$as_me: WARNING: Option --with-custom-make-dir is deprecated and will be ignored." >&2;}
16614 fi
16615 
16616 
16617 
16618 
16619 # These are needed to be able to create a configuration name (and thus the output directory)
16620 
16621   { $as_echo "$as_me:${as_lineno-$LINENO}: checking which variant of the JDK to build" >&5
16622 $as_echo_n "checking which variant of the JDK to build... " >&6; }
16623 
16624 # Check whether --with-jdk-variant was given.
16625 if test "${with_jdk_variant+set}" = set; then :
16626   withval=$with_jdk_variant;
16627 fi
16628 
16629 
16630   if test "x$with_jdk_variant" = xnormal || test "x$with_jdk_variant" = x; then
16631     JDK_VARIANT="normal"
16632   else
16633     as_fn_error $? "The available JDK variants are: normal" "$LINENO" 5
16634   fi
16635 
16636 
16637 
16638   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JDK_VARIANT" >&5
16639 $as_echo "$JDK_VARIANT" >&6; }
16640 
16641 
16642   DEBUG_LEVEL="release"
16643   { $as_echo "$as_me:${as_lineno-$LINENO}: checking which debug level to use" >&5
16644 $as_echo_n "checking which debug level to use... " >&6; }
16645   # Check whether --enable-debug was given.
16646 if test "${enable_debug+set}" = set; then :
16647   enableval=$enable_debug;
16648         ENABLE_DEBUG="${enableval}"
16649         DEBUG_LEVEL="fastdebug"
16650 
16651 else
16652   ENABLE_DEBUG="no"
16653 fi
16654 
16655 
16656 
16657 # Check whether --with-debug-level was given.
16658 if test "${with_debug_level+set}" = set; then :
16659   withval=$with_debug_level;
16660         DEBUG_LEVEL="${withval}"
16661         if test "x$ENABLE_DEBUG" = xyes; then
16662           as_fn_error $? "You cannot use both --enable-debug and --with-debug-level at the same time." "$LINENO" 5
16663         fi
16664 
16665 fi
16666 
16667   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEBUG_LEVEL" >&5
16668 $as_echo "$DEBUG_LEVEL" >&6; }
16669 
16670   if test "x$DEBUG_LEVEL" != xrelease && \
16671       test "x$DEBUG_LEVEL" != xoptimized && \
16672       test "x$DEBUG_LEVEL" != xfastdebug && \
16673       test "x$DEBUG_LEVEL" != xslowdebug; then
16674     as_fn_error $? "Allowed debug levels are: release, fastdebug, slowdebug and optimized" "$LINENO" 5
16675   fi
16676 
16677   # Translate DEBUG_LEVEL to debug level used by Hotspot
16678   HOTSPOT_DEBUG_LEVEL="$DEBUG_LEVEL"
16679   if test "x$DEBUG_LEVEL" = xrelease; then
16680     HOTSPOT_DEBUG_LEVEL="product"
16681   elif test "x$DEBUG_LEVEL" = xslowdebug; then
16682     HOTSPOT_DEBUG_LEVEL="debug"
16683   fi
16684 
16685   if test "x$DEBUG_LEVEL" = xoptimized; then
16686     # The debug level 'optimized' is a little special because it is currently only
16687     # applicable to the HotSpot build where it means to build a completely
16688     # optimized version of the VM without any debugging code (like for the
16689     # 'release' debug level which is called 'product' in the HotSpot build) but
16690     # with the exception that it can contain additional code which is otherwise
16691     # protected by '#ifndef PRODUCT' macros. These 'optimized' builds are used to
16692     # test new and/or experimental features which are not intended for customer
16693     # shipment. Because these new features need to be tested and benchmarked in
16694     # real world scenarios, we want to build the containing JDK at the 'release'
16695     # debug level.
16696     DEBUG_LEVEL="release"
16697   fi
16698 
16699 
16700 
16701 
16702 
16703 
16704 # Check whether --with-jvm-variants was given.
16705 if test "${with_jvm_variants+set}" = set; then :
16706   withval=$with_jvm_variants;
16707 fi
16708 
16709 
16710   if test "x$with_jvm_variants" = x; then
16711     with_jvm_variants="server"
16712   fi
16713   JVM_VARIANTS_OPT="$with_jvm_variants"
16714 
16715   # Has the user listed more than one variant?
16716   # Additional [] needed to keep m4 from mangling shell constructs.
16717   if  [[ "$JVM_VARIANTS_OPT" =~ "," ]] ; then
16718     BUILDING_MULTIPLE_JVM_VARIANTS=true
16719   else
16720     BUILDING_MULTIPLE_JVM_VARIANTS=false
16721   fi
16722   # Replace the commas with AND for use in the build directory name.
16723   JVM_VARIANTS_WITH_AND=`$ECHO "$JVM_VARIANTS_OPT" | $SED -e 's/,/AND/g'`
16724 
16725   { $as_echo "$as_me:${as_lineno-$LINENO}: checking which variants of the JVM to build" >&5
16726 $as_echo_n "checking which variants of the JVM to build... " >&6; }
16727   # JVM_VARIANTS is a space-separated list.
16728   # Also use minimal, not minimal1 (which is kept for backwards compatibility).
16729   JVM_VARIANTS=`$ECHO $JVM_VARIANTS_OPT | $SED -e 's/,/ /g' -e 's/minimal1/minimal/'`
16730   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JVM_VARIANTS" >&5
16731 $as_echo "$JVM_VARIANTS" >&6; }
16732 
16733   # Check that the selected variants are valid
16734 
16735   # grep filter function inspired by a comment to http://stackoverflow.com/a/1617326
16736   # Notice that the original variant failes on SLES 10 and 11
16737   NEEDLE=${VALID_JVM_VARIANTS// /$'\n'}
16738   STACK=${JVM_VARIANTS// /$'\n'}
16739   INVALID_VARIANTS=`$GREP -Fvx "${NEEDLE}" <<< "${STACK}"`
16740   if test "x$INVALID_VARIANTS" != x; then
16741     { $as_echo "$as_me:${as_lineno-$LINENO}: Unknown variant(s) specified: $INVALID_VARIANTS" >&5
16742 $as_echo "$as_me: Unknown variant(s) specified: $INVALID_VARIANTS" >&6;}
16743     as_fn_error $? "The available JVM variants are: $VALID_JVM_VARIANTS" "$LINENO" 5
16744   fi
16745 
16746   # All "special" variants share the same output directory ("server")
16747   VALID_MULTIPLE_JVM_VARIANTS="server client minimal"
16748   NEEDLE=${VALID_MULTIPLE_JVM_VARIANTS// /$'\n'}
16749   STACK=${JVM_VARIANTS// /$'\n'}
16750   INVALID_MULTIPLE_VARIANTS=`$GREP -Fvx "${NEEDLE}" <<< "${STACK}"`
16751   if  test "x$INVALID_MULTIPLE_VARIANTS" != x && test "x$BUILDING_MULTIPLE_JVM_VARIANTS" = xtrue; then
16752     as_fn_error $? "You cannot build multiple variants with anything else than $VALID_MULTIPLE_JVM_VARIANTS." "$LINENO" 5
16753   fi
16754 
16755 
16756 
16757 
16758   if   [[ " $JVM_VARIANTS " =~ " zero " ]]   ||   [[ " $JVM_VARIANTS " =~ " zeroshark " ]]  ; then
16759     # zero behaves as a platform and rewrites these values. This is really weird. :(
16760     # We are guaranteed that we do not build any other variants when building zero.
16761     HOTSPOT_TARGET_CPU=zero
16762     HOTSPOT_TARGET_CPU_ARCH=zero
16763   fi
16764 
16765 
16766 # With basic setup done, call the custom early hook.
16767 
16768 
16769 # Check if we have devkits, extra paths or sysroot set.
16770 
16771 
16772 # Check whether --with-devkit was given.
16773 if test "${with_devkit+set}" = set; then :
16774   withval=$with_devkit;
16775 
16776   # Only process if variable expands to non-empty
16777 
16778   if test "x$with_devkit" != x; then
16779     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16780 
16781   # Input might be given as Windows format, start by converting to
16782   # unix format.
16783   path="$with_devkit"
16784   new_path=`$CYGPATH -u "$path"`
16785 
16786   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
16787   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
16788   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
16789   # "foo.exe" is OK but "foo" is an error.
16790   #
16791   # This test is therefore slightly more accurate than "test -f" to check for file precense.
16792   # It is also a way to make sure we got the proper file name for the real test later on.
16793   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
16794   if test "x$test_shortpath" = x; then
16795     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
16796 $as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
16797     as_fn_error $? "Cannot locate the the path of with_devkit" "$LINENO" 5
16798   fi
16799 
16800   # Call helper function which possibly converts this using DOS-style short mode.
16801   # If so, the updated path is stored in $new_path.
16802 
16803   input_path="$new_path"
16804   # Check if we need to convert this using DOS-style short mode. If the path
16805   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16806   # take no chances and rewrite it.
16807   # Note: m4 eats our [], so we need to use [ and ] instead.
16808   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
16809   if test "x$has_forbidden_chars" != x; then
16810     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16811     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
16812     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
16813     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
16814       # Going to short mode and back again did indeed matter. Since short mode is
16815       # case insensitive, let's make it lowercase to improve readability.
16816       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16817       # Now convert it back to Unix-style (cygpath)
16818       input_path=`$CYGPATH -u "$shortmode_path"`
16819       new_path="$input_path"
16820     fi
16821   fi
16822 
16823   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
16824   if test "x$test_cygdrive_prefix" = x; then
16825     # As a simple fix, exclude /usr/bin since it's not a real path.
16826     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
16827       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
16828       # a path prefixed by /cygdrive for fixpath to work.
16829       new_path="$CYGWIN_ROOT_PATH$input_path"
16830     fi
16831   fi
16832 
16833 
16834   if test "x$path" != "x$new_path"; then
16835     with_devkit="$new_path"
16836     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
16837 $as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
16838   fi
16839 
16840     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16841 
16842   path="$with_devkit"
16843   has_colon=`$ECHO $path | $GREP ^.:`
16844   new_path="$path"
16845   if test "x$has_colon" = x; then
16846     # Not in mixed or Windows style, start by that.
16847     new_path=`cmd //c echo $path`
16848   fi
16849 
16850 
16851   input_path="$new_path"
16852   # Check if we need to convert this using DOS-style short mode. If the path
16853   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16854   # take no chances and rewrite it.
16855   # Note: m4 eats our [], so we need to use [ and ] instead.
16856   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
16857   if test "x$has_forbidden_chars" != x; then
16858     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16859     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16860   fi
16861 
16862 
16863   windows_path="$new_path"
16864   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16865     unix_path=`$CYGPATH -u "$windows_path"`
16866     new_path="$unix_path"
16867   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16868     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16869     new_path="$unix_path"
16870   fi
16871 
16872   if test "x$path" != "x$new_path"; then
16873     with_devkit="$new_path"
16874     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
16875 $as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
16876   fi
16877 
16878   # Save the first 10 bytes of this path to the storage, so fixpath can work.
16879   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
16880 
16881     else
16882       # We're on a unix platform. Hooray! :)
16883       path="$with_devkit"
16884       has_space=`$ECHO "$path" | $GREP " "`
16885       if test "x$has_space" != x; then
16886         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
16887 $as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
16888         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
16889       fi
16890 
16891       # Use eval to expand a potential ~
16892       eval path="$path"
16893       if test ! -f "$path" && test ! -d "$path"; then
16894         as_fn_error $? "The path of with_devkit, which resolves as \"$path\", is not found." "$LINENO" 5
16895       fi
16896 
16897       if test -d "$path"; then
16898         with_devkit="`cd "$path"; $THEPWDCMD -L`"
16899       else
16900         dir="`$DIRNAME "$path"`"
16901         base="`$BASENAME "$path"`"
16902         with_devkit="`cd "$dir"; $THEPWDCMD -L`/$base"
16903       fi
16904     fi
16905   fi
16906 
16907         DEVKIT_ROOT="$with_devkit"
16908         # Check for a meta data info file in the root of the devkit
16909         if test -f "$DEVKIT_ROOT/devkit.info"; then
16910           . $DEVKIT_ROOT/devkit.info
16911           # This potentially sets the following:
16912           # A descriptive name of the devkit
16913 
16914   if test "x$DEVKIT_NAME" = x; then
16915     eval DEVKIT_NAME="\${DEVKIT_NAME_${OPENJDK_TARGET_CPU}}"
16916   fi
16917 
16918           # Corresponds to --with-extra-path
16919 
16920   if test "x$DEVKIT_EXTRA_PATH" = x; then
16921     eval DEVKIT_EXTRA_PATH="\${DEVKIT_EXTRA_PATH_${OPENJDK_TARGET_CPU}}"
16922   fi
16923 
16924           # Corresponds to --with-toolchain-path
16925 
16926   if test "x$DEVKIT_TOOLCHAIN_PATH" = x; then
16927     eval DEVKIT_TOOLCHAIN_PATH="\${DEVKIT_TOOLCHAIN_PATH_${OPENJDK_TARGET_CPU}}"
16928   fi
16929 
16930           # Corresponds to --with-sysroot
16931 
16932   if test "x$DEVKIT_SYSROOT" = x; then
16933     eval DEVKIT_SYSROOT="\${DEVKIT_SYSROOT_${OPENJDK_TARGET_CPU}}"
16934   fi
16935 
16936 
16937           # Identifies the Visual Studio version in the devkit
16938 
16939   if test "x$DEVKIT_VS_VERSION" = x; then
16940     eval DEVKIT_VS_VERSION="\${DEVKIT_VS_VERSION_${OPENJDK_TARGET_CPU}}"
16941   fi
16942 
16943           # The Visual Studio include environment variable
16944 
16945   if test "x$DEVKIT_VS_INCLUDE" = x; then
16946     eval DEVKIT_VS_INCLUDE="\${DEVKIT_VS_INCLUDE_${OPENJDK_TARGET_CPU}}"
16947   fi
16948 
16949           # The Visual Studio lib environment variable
16950 
16951   if test "x$DEVKIT_VS_LIB" = x; then
16952     eval DEVKIT_VS_LIB="\${DEVKIT_VS_LIB_${OPENJDK_TARGET_CPU}}"
16953   fi
16954 
16955           # Corresponds to --with-msvcr-dll
16956 
16957   if test "x$DEVKIT_MSVCR_DLL" = x; then
16958     eval DEVKIT_MSVCR_DLL="\${DEVKIT_MSVCR_DLL_${OPENJDK_TARGET_CPU}}"
16959   fi
16960 
16961           # Corresponds to --with-msvcp-dll
16962 
16963   if test "x$DEVKIT_MSVCP_DLL" = x; then
16964     eval DEVKIT_MSVCP_DLL="\${DEVKIT_MSVCP_DLL_${OPENJDK_TARGET_CPU}}"
16965   fi
16966 
16967         fi
16968 
16969         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for devkit" >&5
16970 $as_echo_n "checking for devkit... " >&6; }
16971         if test "x$DEVKIT_NAME" != x; then
16972           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEVKIT_NAME in $DEVKIT_ROOT" >&5
16973 $as_echo "$DEVKIT_NAME in $DEVKIT_ROOT" >&6; }
16974         else
16975           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEVKIT_ROOT" >&5
16976 $as_echo "$DEVKIT_ROOT" >&6; }
16977         fi
16978 
16979 
16980   if test "x$DEVKIT_EXTRA_PATH" != x; then
16981     if test "x$EXTRA_PATH" = x; then
16982       EXTRA_PATH="$DEVKIT_EXTRA_PATH"
16983     else
16984       EXTRA_PATH="$DEVKIT_EXTRA_PATH:$EXTRA_PATH"
16985     fi
16986   fi
16987 
16988 
16989         # Fallback default of just /bin if DEVKIT_PATH is not defined
16990         if test "x$DEVKIT_TOOLCHAIN_PATH" = x; then
16991           DEVKIT_TOOLCHAIN_PATH="$DEVKIT_ROOT/bin"
16992         fi
16993 
16994   if test "x$DEVKIT_TOOLCHAIN_PATH" != x; then
16995     if test "x$TOOLCHAIN_PATH" = x; then
16996       TOOLCHAIN_PATH="$DEVKIT_TOOLCHAIN_PATH"
16997     else
16998       TOOLCHAIN_PATH="$DEVKIT_TOOLCHAIN_PATH:$TOOLCHAIN_PATH"
16999     fi
17000   fi
17001 
17002 
17003         # If DEVKIT_SYSROOT is set, use that, otherwise try a couple of known
17004         # places for backwards compatiblity.
17005         if test "x$DEVKIT_SYSROOT" != x; then
17006           SYSROOT="$DEVKIT_SYSROOT"
17007         elif test -d "$DEVKIT_ROOT/$host_alias/libc"; then
17008           SYSROOT="$DEVKIT_ROOT/$host_alias/libc"
17009         elif test -d "$DEVKIT_ROOT/$host/sys-root"; then
17010           SYSROOT="$DEVKIT_ROOT/$host/sys-root"
17011         fi
17012 
17013 
17014 fi
17015 
17016 
17017   # You can force the sysroot if the sysroot encoded into the compiler tools
17018   # is not correct.
17019 
17020 # Check whether --with-sys-root was given.
17021 if test "${with_sys_root+set}" = set; then :
17022   withval=$with_sys_root; SYSROOT=$with_sys_root
17023 
17024 fi
17025 
17026 
17027 
17028 # Check whether --with-sysroot was given.
17029 if test "${with_sysroot+set}" = set; then :
17030   withval=$with_sysroot; SYSROOT=$with_sysroot
17031 
17032 fi
17033 
17034 
17035 
17036 # Check whether --with-tools-dir was given.
17037 if test "${with_tools_dir+set}" = set; then :
17038   withval=$with_tools_dir;
17039   if test "x$with_tools_dir" != x; then
17040     if test "x$TOOLCHAIN_PATH" = x; then
17041       TOOLCHAIN_PATH="$with_tools_dir"
17042     else
17043       TOOLCHAIN_PATH="$with_tools_dir:$TOOLCHAIN_PATH"
17044     fi
17045   fi
17046 
17047 
17048 fi
17049 
17050 
17051 
17052 # Check whether --with-toolchain-path was given.
17053 if test "${with_toolchain_path+set}" = set; then :
17054   withval=$with_toolchain_path;
17055   if test "x$with_toolchain_path" != x; then
17056     if test "x$TOOLCHAIN_PATH" = x; then
17057       TOOLCHAIN_PATH="$with_toolchain_path"
17058     else
17059       TOOLCHAIN_PATH="$with_toolchain_path:$TOOLCHAIN_PATH"
17060     fi
17061   fi
17062 
17063 
17064 fi
17065 
17066 
17067 
17068 # Check whether --with-extra-path was given.
17069 if test "${with_extra_path+set}" = set; then :
17070   withval=$with_extra_path;
17071   if test "x$with_extra_path" != x; then
17072     if test "x$EXTRA_PATH" = x; then
17073       EXTRA_PATH="$with_extra_path"
17074     else
17075       EXTRA_PATH="$with_extra_path:$EXTRA_PATH"
17076     fi
17077   fi
17078 
17079 
17080 fi
17081 
17082 
17083   if test "x$OPENJDK_BUILD_OS" = "xmacosx"; then
17084     # If a devkit has been supplied, find xcodebuild in the toolchain_path.
17085     # If not, detect if Xcode is installed by running xcodebuild -version
17086     # if no Xcode installed, xcodebuild exits with 1
17087     # if Xcode is installed, even if xcode-select is misconfigured, then it exits with 0
17088     if test "x$DEVKIT_ROOT" != x || /usr/bin/xcodebuild -version >/dev/null 2>&1; then
17089       # We need to use xcodebuild in the toolchain dir provided by the user, this will
17090       # fall back on the stub binary in /usr/bin/xcodebuild
17091       # Extract the first word of "xcodebuild", so it can be a program name with args.
17092 set dummy xcodebuild; ac_word=$2
17093 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17094 $as_echo_n "checking for $ac_word... " >&6; }
17095 if ${ac_cv_path_XCODEBUILD+:} false; then :
17096   $as_echo_n "(cached) " >&6
17097 else
17098   case $XCODEBUILD in
17099   [\\/]* | ?:[\\/]*)
17100   ac_cv_path_XCODEBUILD="$XCODEBUILD" # Let the user override the test with a path.
17101   ;;
17102   *)
17103   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17104 for as_dir in $TOOLCHAIN_PATH
17105 do
17106   IFS=$as_save_IFS
17107   test -z "$as_dir" && as_dir=.
17108     for ac_exec_ext in '' $ac_executable_extensions; do
17109   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17110     ac_cv_path_XCODEBUILD="$as_dir/$ac_word$ac_exec_ext"
17111     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17112     break 2
17113   fi
17114 done
17115   done
17116 IFS=$as_save_IFS
17117 
17118   test -z "$ac_cv_path_XCODEBUILD" && ac_cv_path_XCODEBUILD="/usr/bin/xcodebuild"
17119   ;;
17120 esac
17121 fi
17122 XCODEBUILD=$ac_cv_path_XCODEBUILD
17123 if test -n "$XCODEBUILD"; then
17124   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XCODEBUILD" >&5
17125 $as_echo "$XCODEBUILD" >&6; }
17126 else
17127   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17128 $as_echo "no" >&6; }
17129 fi
17130 
17131 
17132     else
17133       # this should result in SYSROOT being empty, unless --with-sysroot is provided
17134       # when only the command line tools are installed there are no SDKs, so headers
17135       # are copied into the system frameworks
17136       XCODEBUILD=
17137 
17138     fi
17139 
17140     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for sdk name" >&5
17141 $as_echo_n "checking for sdk name... " >&6; }
17142 
17143 # Check whether --with-sdk-name was given.
17144 if test "${with_sdk_name+set}" = set; then :
17145   withval=$with_sdk_name; SDKNAME=$with_sdk_name
17146 
17147 fi
17148 
17149     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SDKNAME" >&5
17150 $as_echo "$SDKNAME" >&6; }
17151 
17152     # if toolchain path is specified then don't rely on system headers, they may not compile
17153     HAVE_SYSTEM_FRAMEWORK_HEADERS=0
17154     test -z "$TOOLCHAIN_PATH" && \
17155       HAVE_SYSTEM_FRAMEWORK_HEADERS=`test ! -f /System/Library/Frameworks/Foundation.framework/Headers/Foundation.h; echo $?`
17156 
17157     if test -z "$SYSROOT"; then
17158       if test -n "$XCODEBUILD"; then
17159         # if we don't have system headers, use default SDK name (last resort)
17160         if test -z "$SDKNAME" -a $HAVE_SYSTEM_FRAMEWORK_HEADERS -eq 0; then
17161           SDKNAME=${SDKNAME:-macosx}
17162         fi
17163 
17164         if test -n "$SDKNAME"; then
17165           # Call xcodebuild to determine SYSROOT
17166           SYSROOT=`"$XCODEBUILD" -sdk $SDKNAME -version | $GREP '^Path: ' | $SED 's/Path: //'`
17167         fi
17168       else
17169         if test $HAVE_SYSTEM_FRAMEWORK_HEADERS -eq 0; then
17170           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
17171         fi
17172       fi
17173     else
17174       # warn user if --with-sdk-name was also set
17175       if test -n "$with_sdk_name"; then
17176         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Both SYSROOT and --with-sdk-name are set, only SYSROOT will be used" >&5
17177 $as_echo "$as_me: WARNING: Both SYSROOT and --with-sdk-name are set, only SYSROOT will be used" >&2;}
17178       fi
17179     fi
17180 
17181     if test $HAVE_SYSTEM_FRAMEWORK_HEADERS -eq 0 -a -z "$SYSROOT"; then
17182       # If no system framework headers, then SYSROOT must be set, or we won't build
17183       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
17184     fi
17185 
17186     # Perform a basic sanity test
17187     if test ! -f "$SYSROOT/System/Library/Frameworks/Foundation.framework/Headers/Foundation.h"; then
17188       if test -z "$SYSROOT"; then
17189         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
17190       else
17191         as_fn_error $? "Invalid SDK or SYSROOT path, dependent framework headers not found" "$LINENO" 5
17192       fi
17193     fi
17194 
17195     # set SDKROOT too, Xcode tools will pick it up
17196     SDKROOT=$SYSROOT
17197 
17198   fi
17199 
17200   # Prepend the extra path to the global path
17201 
17202   if test "x$EXTRA_PATH" != x; then
17203     if test "x$PATH" = x; then
17204       PATH="$EXTRA_PATH"
17205     else
17206       PATH="$EXTRA_PATH:$PATH"
17207     fi
17208   fi
17209 
17210 
17211   if test "x$OPENJDK_BUILD_OS" = "xsolaris"; then
17212     # Add extra search paths on solaris for utilities like ar, as, dtrace etc...
17213     PATH="$PATH:/usr/ccs/bin:/usr/sfw/bin:/opt/csw/bin:/usr/sbin"
17214   fi
17215 
17216   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for sysroot" >&5
17217 $as_echo_n "checking for sysroot... " >&6; }
17218   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SYSROOT" >&5
17219 $as_echo "$SYSROOT" >&6; }
17220   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for toolchain path" >&5
17221 $as_echo_n "checking for toolchain path... " >&6; }
17222   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOOLCHAIN_PATH" >&5
17223 $as_echo "$TOOLCHAIN_PATH" >&6; }
17224   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for extra path" >&5
17225 $as_echo_n "checking for extra path... " >&6; }
17226   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXTRA_PATH" >&5
17227 $as_echo "$EXTRA_PATH" >&6; }
17228 
17229 
17230 # To properly create a configuration name, we need to have the OpenJDK target
17231 # and options (variants and debug level) parsed.
17232 
17233 
17234 
17235 # Check whether --with-conf-name was given.
17236 if test "${with_conf_name+set}" = set; then :
17237   withval=$with_conf_name;  CONF_NAME=${with_conf_name}
17238 fi
17239 
17240 
17241   # Test from where we are running configure, in or outside of src root.
17242   { $as_echo "$as_me:${as_lineno-$LINENO}: checking where to store configuration" >&5
17243 $as_echo_n "checking where to store configuration... " >&6; }
17244   if test "x$CURDIR" = "x$SRC_ROOT" || test "x$CURDIR" = "x$SRC_ROOT/common" \
17245       || test "x$CURDIR" = "x$SRC_ROOT/common/autoconf" \
17246       || test "x$CURDIR" = "x$SRC_ROOT/make" ; then
17247     # We are running configure from the src root.
17248     # Create a default ./build/target-variant-debuglevel output root.
17249     if test "x${CONF_NAME}" = x; then
17250       { $as_echo "$as_me:${as_lineno-$LINENO}: result: in default location" >&5
17251 $as_echo "in default location" >&6; }
17252       CONF_NAME="${OPENJDK_TARGET_OS}-${OPENJDK_TARGET_CPU}-${JDK_VARIANT}-${JVM_VARIANTS_WITH_AND}-${DEBUG_LEVEL}"
17253     else
17254       { $as_echo "$as_me:${as_lineno-$LINENO}: result: in build directory with custom name" >&5
17255 $as_echo "in build directory with custom name" >&6; }
17256     fi
17257     OUTPUT_ROOT="$SRC_ROOT/build/${CONF_NAME}"
17258     $MKDIR -p "$OUTPUT_ROOT"
17259     if test ! -d "$OUTPUT_ROOT"; then
17260       as_fn_error $? "Could not create build directory $OUTPUT_ROOT" "$LINENO" 5
17261     fi
17262   else
17263     # We are running configure from outside of the src dir.
17264     # Then use the current directory as output dir!
17265     # If configuration is situated in normal build directory, just use the build
17266     # directory name as configuration name, otherwise use the complete path.
17267     if test "x${CONF_NAME}" = x; then
17268       CONF_NAME=`$ECHO $CURDIR | $SED -e "s!^${SRC_ROOT}/build/!!"`
17269     fi
17270     OUTPUT_ROOT="$CURDIR"
17271     { $as_echo "$as_me:${as_lineno-$LINENO}: result: in current directory" >&5
17272 $as_echo "in current directory" >&6; }
17273 
17274     # WARNING: This might be a bad thing to do. You need to be sure you want to
17275     # have a configuration in this directory. Do some sanity checks!
17276 
17277     if test ! -e "$OUTPUT_ROOT/spec.gmk"; then
17278       # If we have a spec.gmk, we have run here before and we are OK. Otherwise, check for
17279       # other files
17280       files_present=`$LS $OUTPUT_ROOT`
17281       # Configure has already touched config.log and confdefs.h in the current dir when this check
17282       # is performed.
17283       filtered_files=`$ECHO "$files_present" \
17284           | $SED -e 's/config.log//g' \
17285               -e 's/configure.log//g' \
17286               -e 's/confdefs.h//g' \
17287               -e 's/ //g' \
17288           | $TR -d '\n'`
17289       if test "x$filtered_files" != x; then
17290         { $as_echo "$as_me:${as_lineno-$LINENO}: Current directory is $CURDIR." >&5
17291 $as_echo "$as_me: Current directory is $CURDIR." >&6;}
17292         { $as_echo "$as_me:${as_lineno-$LINENO}: Since this is not the source root, configure will output the configuration here" >&5
17293 $as_echo "$as_me: Since this is not the source root, configure will output the configuration here" >&6;}
17294         { $as_echo "$as_me:${as_lineno-$LINENO}: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&5
17295 $as_echo "$as_me: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&6;}
17296         { $as_echo "$as_me:${as_lineno-$LINENO}: However, this directory is not empty. This is not allowed, since it could" >&5
17297 $as_echo "$as_me: However, this directory is not empty. This is not allowed, since it could" >&6;}
17298         { $as_echo "$as_me:${as_lineno-$LINENO}: seriously mess up just about everything." >&5
17299 $as_echo "$as_me: seriously mess up just about everything." >&6;}
17300         { $as_echo "$as_me:${as_lineno-$LINENO}: Try 'cd $SRC_ROOT' and restart configure" >&5
17301 $as_echo "$as_me: Try 'cd $SRC_ROOT' and restart configure" >&6;}
17302         { $as_echo "$as_me:${as_lineno-$LINENO}: (or create a new empty directory and cd to it)." >&5
17303 $as_echo "$as_me: (or create a new empty directory and cd to it)." >&6;}
17304         as_fn_error $? "Will not continue creating configuration in $CURDIR" "$LINENO" 5
17305       fi
17306     fi
17307   fi
17308   { $as_echo "$as_me:${as_lineno-$LINENO}: checking what configuration name to use" >&5
17309 $as_echo_n "checking what configuration name to use... " >&6; }
17310   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CONF_NAME" >&5
17311 $as_echo "$CONF_NAME" >&6; }
17312 
17313 
17314   # Only process if variable expands to non-empty
17315 
17316   if test "x$OUTPUT_ROOT" != x; then
17317     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17318 
17319   # Input might be given as Windows format, start by converting to
17320   # unix format.
17321   path="$OUTPUT_ROOT"
17322   new_path=`$CYGPATH -u "$path"`
17323 
17324   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
17325   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
17326   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
17327   # "foo.exe" is OK but "foo" is an error.
17328   #
17329   # This test is therefore slightly more accurate than "test -f" to check for file precense.
17330   # It is also a way to make sure we got the proper file name for the real test later on.
17331   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
17332   if test "x$test_shortpath" = x; then
17333     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&5
17334 $as_echo "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&6;}
17335     as_fn_error $? "Cannot locate the the path of OUTPUT_ROOT" "$LINENO" 5
17336   fi
17337 
17338   # Call helper function which possibly converts this using DOS-style short mode.
17339   # If so, the updated path is stored in $new_path.
17340 
17341   input_path="$new_path"
17342   # Check if we need to convert this using DOS-style short mode. If the path
17343   # contains just simple characters, use it. Otherwise (spaces, weird characters),
17344   # take no chances and rewrite it.
17345   # Note: m4 eats our [], so we need to use [ and ] instead.
17346   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
17347   if test "x$has_forbidden_chars" != x; then
17348     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
17349     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
17350     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
17351     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
17352       # Going to short mode and back again did indeed matter. Since short mode is
17353       # case insensitive, let's make it lowercase to improve readability.
17354       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
17355       # Now convert it back to Unix-style (cygpath)
17356       input_path=`$CYGPATH -u "$shortmode_path"`
17357       new_path="$input_path"
17358     fi
17359   fi
17360 
17361   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
17362   if test "x$test_cygdrive_prefix" = x; then
17363     # As a simple fix, exclude /usr/bin since it's not a real path.
17364     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
17365       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
17366       # a path prefixed by /cygdrive for fixpath to work.
17367       new_path="$CYGWIN_ROOT_PATH$input_path"
17368     fi
17369   fi
17370 
17371 
17372   if test "x$path" != "x$new_path"; then
17373     OUTPUT_ROOT="$new_path"
17374     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
17375 $as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
17376   fi
17377 
17378     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17379 
17380   path="$OUTPUT_ROOT"
17381   has_colon=`$ECHO $path | $GREP ^.:`
17382   new_path="$path"
17383   if test "x$has_colon" = x; then
17384     # Not in mixed or Windows style, start by that.
17385     new_path=`cmd //c echo $path`
17386   fi
17387 
17388 
17389   input_path="$new_path"
17390   # Check if we need to convert this using DOS-style short mode. If the path
17391   # contains just simple characters, use it. Otherwise (spaces, weird characters),
17392   # take no chances and rewrite it.
17393   # Note: m4 eats our [], so we need to use [ and ] instead.
17394   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
17395   if test "x$has_forbidden_chars" != x; then
17396     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
17397     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
17398   fi
17399 
17400 
17401   windows_path="$new_path"
17402   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17403     unix_path=`$CYGPATH -u "$windows_path"`
17404     new_path="$unix_path"
17405   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17406     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17407     new_path="$unix_path"
17408   fi
17409 
17410   if test "x$path" != "x$new_path"; then
17411     OUTPUT_ROOT="$new_path"
17412     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
17413 $as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
17414   fi
17415 
17416   # Save the first 10 bytes of this path to the storage, so fixpath can work.
17417   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
17418 
17419     else
17420       # We're on a unix platform. Hooray! :)
17421       path="$OUTPUT_ROOT"
17422       has_space=`$ECHO "$path" | $GREP " "`
17423       if test "x$has_space" != x; then
17424         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&5
17425 $as_echo "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&6;}
17426         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
17427       fi
17428 
17429       # Use eval to expand a potential ~
17430       eval path="$path"
17431       if test ! -f "$path" && test ! -d "$path"; then
17432         as_fn_error $? "The path of OUTPUT_ROOT, which resolves as \"$path\", is not found." "$LINENO" 5
17433       fi
17434 
17435       if test -d "$path"; then
17436         OUTPUT_ROOT="`cd "$path"; $THEPWDCMD -L`"
17437       else
17438         dir="`$DIRNAME "$path"`"
17439         base="`$BASENAME "$path"`"
17440         OUTPUT_ROOT="`cd "$dir"; $THEPWDCMD -L`/$base"
17441       fi
17442     fi
17443   fi
17444 
17445 
17446   CONFIGURESUPPORT_OUTPUTDIR="$OUTPUT_ROOT/configure-support"
17447   $MKDIR -p "$CONFIGURESUPPORT_OUTPUTDIR"
17448 
17449   SPEC=$OUTPUT_ROOT/spec.gmk
17450 
17451   CONF_NAME=$CONF_NAME
17452 
17453   OUTPUT_ROOT=$OUTPUT_ROOT
17454 
17455 
17456 
17457   # The spec.gmk file contains all variables for the make system.
17458   ac_config_files="$ac_config_files $OUTPUT_ROOT/spec.gmk:$AUTOCONF_DIR/spec.gmk.in"
17459 
17460   # The bootcycle-spec.gmk file contains support for boot cycle builds.
17461   ac_config_files="$ac_config_files $OUTPUT_ROOT/bootcycle-spec.gmk:$AUTOCONF_DIR/bootcycle-spec.gmk.in"
17462 
17463   # The buildjdk-spec.gmk file contains support for building a buildjdk when cross compiling.
17464   ac_config_files="$ac_config_files $OUTPUT_ROOT/buildjdk-spec.gmk:$AUTOCONF_DIR/buildjdk-spec.gmk.in"
17465 
17466   # The compare.sh is used to compare the build output to other builds.
17467   ac_config_files="$ac_config_files $OUTPUT_ROOT/compare.sh:$AUTOCONF_DIR/compare.sh.in"
17468 
17469   # The generated Makefile knows where the spec.gmk is and where the source is.
17470   # You can run make from the OUTPUT_ROOT, or from the top-level Makefile
17471   # which will look for generated configurations
17472   ac_config_files="$ac_config_files $OUTPUT_ROOT/Makefile:$AUTOCONF_DIR/Makefile.in"
17473 
17474 
17475 
17476 # Must be done before we can call HELP_MSG_MISSING_DEPENDENCY.
17477 
17478   for ac_prog in apt-get yum port pkgutil pkgadd
17479 do
17480   # Extract the first word of "$ac_prog", so it can be a program name with args.
17481 set dummy $ac_prog; ac_word=$2
17482 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17483 $as_echo_n "checking for $ac_word... " >&6; }
17484 if ${ac_cv_prog_PKGHANDLER+:} false; then :
17485   $as_echo_n "(cached) " >&6
17486 else
17487   if test -n "$PKGHANDLER"; then
17488   ac_cv_prog_PKGHANDLER="$PKGHANDLER" # Let the user override the test.
17489 else
17490 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17491 for as_dir in $PATH
17492 do
17493   IFS=$as_save_IFS
17494   test -z "$as_dir" && as_dir=.
17495     for ac_exec_ext in '' $ac_executable_extensions; do
17496   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17497     ac_cv_prog_PKGHANDLER="$ac_prog"
17498     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17499     break 2
17500   fi
17501 done
17502   done
17503 IFS=$as_save_IFS
17504 
17505 fi
17506 fi
17507 PKGHANDLER=$ac_cv_prog_PKGHANDLER
17508 if test -n "$PKGHANDLER"; then
17509   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKGHANDLER" >&5
17510 $as_echo "$PKGHANDLER" >&6; }
17511 else
17512   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17513 $as_echo "no" >&6; }
17514 fi
17515 
17516 
17517   test -n "$PKGHANDLER" && break
17518 done
17519 
17520 
17521 
17522 # Setup tools that requires more complex handling, or that is not needed by the configure script.
17523 
17524 
17525 
17526   # Publish this variable in the help.
17527 
17528 
17529   if [ -z "${MAKE+x}" ]; then
17530     # The variable is not set by user, try to locate tool using the code snippet
17531 
17532     # Try our hardest to locate a correct version of GNU make
17533     for ac_prog in gmake
17534 do
17535   # Extract the first word of "$ac_prog", so it can be a program name with args.
17536 set dummy $ac_prog; ac_word=$2
17537 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17538 $as_echo_n "checking for $ac_word... " >&6; }
17539 if ${ac_cv_path_CHECK_GMAKE+:} false; then :
17540   $as_echo_n "(cached) " >&6
17541 else
17542   case $CHECK_GMAKE in
17543   [\\/]* | ?:[\\/]*)
17544   ac_cv_path_CHECK_GMAKE="$CHECK_GMAKE" # Let the user override the test with a path.
17545   ;;
17546   *)
17547   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17548 for as_dir in $PATH
17549 do
17550   IFS=$as_save_IFS
17551   test -z "$as_dir" && as_dir=.
17552     for ac_exec_ext in '' $ac_executable_extensions; do
17553   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17554     ac_cv_path_CHECK_GMAKE="$as_dir/$ac_word$ac_exec_ext"
17555     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17556     break 2
17557   fi
17558 done
17559   done
17560 IFS=$as_save_IFS
17561 
17562   ;;
17563 esac
17564 fi
17565 CHECK_GMAKE=$ac_cv_path_CHECK_GMAKE
17566 if test -n "$CHECK_GMAKE"; then
17567   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_GMAKE" >&5
17568 $as_echo "$CHECK_GMAKE" >&6; }
17569 else
17570   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17571 $as_echo "no" >&6; }
17572 fi
17573 
17574 
17575   test -n "$CHECK_GMAKE" && break
17576 done
17577 
17578 
17579   MAKE_CANDIDATE=""$CHECK_GMAKE""
17580   DESCRIPTION="gmake in PATH"
17581 
17582   # On Cygwin, we require a newer version of make than on other platforms
17583   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17584     MAKE_VERSION_EXPR="-e 4\."
17585     MAKE_REQUIRED_VERSION="4.0"
17586    else
17587     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
17588     MAKE_REQUIRED_VERSION="3.81"
17589   fi
17590 
17591   if test "x$MAKE_CANDIDATE" != x; then
17592     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
17593 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
17594     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
17595     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
17596     if test "x$IS_GNU_MAKE" = x; then
17597       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
17598 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
17599     else
17600       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
17601       if test "x$IS_MODERN_MAKE" = x; then
17602         { $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
17603 $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;}
17604       else
17605         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
17606           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17607             MAKE_EXPECTED_ENV='cygwin'
17608           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17609             MAKE_EXPECTED_ENV='msys'
17610           else
17611             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
17612           fi
17613           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
17614           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
17615         else
17616           # Not relevant for non-Windows
17617           IS_MAKE_CORRECT_ENV=true
17618         fi
17619         if test "x$IS_MAKE_CORRECT_ENV" = x; then
17620           { $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
17621 $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;}
17622         else
17623           FOUND_MAKE=$MAKE_CANDIDATE
17624 
17625   # Only process if variable expands to non-empty
17626 
17627   if test "x$FOUND_MAKE" != x; then
17628     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17629 
17630   # First separate the path from the arguments. This will split at the first
17631   # space.
17632   complete="$FOUND_MAKE"
17633   path="${complete%% *}"
17634   tmp="$complete EOL"
17635   arguments="${tmp#* }"
17636 
17637   # Input might be given as Windows format, start by converting to
17638   # unix format.
17639   new_path=`$CYGPATH -u "$path"`
17640 
17641   # Now try to locate executable using which
17642   new_path=`$WHICH "$new_path" 2> /dev/null`
17643   # bat and cmd files are not always considered executable in cygwin causing which
17644   # to not find them
17645   if test "x$new_path" = x \
17646       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17647       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17648     new_path=`$CYGPATH -u "$path"`
17649   fi
17650   if test "x$new_path" = x; then
17651     # Oops. Which didn't find the executable.
17652     # The splitting of arguments from the executable at a space might have been incorrect,
17653     # since paths with space are more likely in Windows. Give it another try with the whole
17654     # argument.
17655     path="$complete"
17656     arguments="EOL"
17657     new_path=`$CYGPATH -u "$path"`
17658     new_path=`$WHICH "$new_path" 2> /dev/null`
17659     # bat and cmd files are not always considered executable in cygwin causing which
17660     # to not find them
17661     if test "x$new_path" = x \
17662         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17663         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17664       new_path=`$CYGPATH -u "$path"`
17665     fi
17666     if test "x$new_path" = x; then
17667       # It's still not found. Now this is an unrecoverable error.
17668       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17669 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17670       has_space=`$ECHO "$complete" | $GREP " "`
17671       if test "x$has_space" != x; then
17672         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
17673 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
17674       fi
17675       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17676     fi
17677   fi
17678 
17679   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
17680   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
17681   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
17682   # "foo.exe" is OK but "foo" is an error.
17683   #
17684   # This test is therefore slightly more accurate than "test -f" to check for file presence.
17685   # It is also a way to make sure we got the proper file name for the real test later on.
17686   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
17687   if test "x$test_shortpath" = x; then
17688     # Short path failed, file does not exist as specified.
17689     # Try adding .exe or .cmd
17690     if test -f "${new_path}.exe"; then
17691       input_to_shortpath="${new_path}.exe"
17692     elif test -f "${new_path}.cmd"; then
17693       input_to_shortpath="${new_path}.cmd"
17694     else
17695       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
17696 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
17697       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
17698 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
17699       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17700     fi
17701   else
17702     input_to_shortpath="$new_path"
17703   fi
17704 
17705   # Call helper function which possibly converts this using DOS-style short mode.
17706   # If so, the updated path is stored in $new_path.
17707   new_path="$input_to_shortpath"
17708 
17709   input_path="$input_to_shortpath"
17710   # Check if we need to convert this using DOS-style short mode. If the path
17711   # contains just simple characters, use it. Otherwise (spaces, weird characters),
17712   # take no chances and rewrite it.
17713   # Note: m4 eats our [], so we need to use [ and ] instead.
17714   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
17715   if test "x$has_forbidden_chars" != x; then
17716     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
17717     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
17718     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
17719     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
17720       # Going to short mode and back again did indeed matter. Since short mode is
17721       # case insensitive, let's make it lowercase to improve readability.
17722       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
17723       # Now convert it back to Unix-style (cygpath)
17724       input_path=`$CYGPATH -u "$shortmode_path"`
17725       new_path="$input_path"
17726     fi
17727   fi
17728 
17729   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
17730   if test "x$test_cygdrive_prefix" = x; then
17731     # As a simple fix, exclude /usr/bin since it's not a real path.
17732     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
17733       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
17734       # a path prefixed by /cygdrive for fixpath to work.
17735       new_path="$CYGWIN_ROOT_PATH$input_path"
17736     fi
17737   fi
17738 
17739   # remove trailing .exe if any
17740   new_path="${new_path/%.exe/}"
17741 
17742     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17743 
17744   # First separate the path from the arguments. This will split at the first
17745   # space.
17746   complete="$FOUND_MAKE"
17747   path="${complete%% *}"
17748   tmp="$complete EOL"
17749   arguments="${tmp#* }"
17750 
17751   # Input might be given as Windows format, start by converting to
17752   # unix format.
17753   new_path="$path"
17754 
17755   windows_path="$new_path"
17756   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17757     unix_path=`$CYGPATH -u "$windows_path"`
17758     new_path="$unix_path"
17759   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17760     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17761     new_path="$unix_path"
17762   fi
17763 
17764 
17765   # Now try to locate executable using which
17766   new_path=`$WHICH "$new_path" 2> /dev/null`
17767 
17768   if test "x$new_path" = x; then
17769     # Oops. Which didn't find the executable.
17770     # The splitting of arguments from the executable at a space might have been incorrect,
17771     # since paths with space are more likely in Windows. Give it another try with the whole
17772     # argument.
17773     path="$complete"
17774     arguments="EOL"
17775     new_path="$path"
17776 
17777   windows_path="$new_path"
17778   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17779     unix_path=`$CYGPATH -u "$windows_path"`
17780     new_path="$unix_path"
17781   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17782     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17783     new_path="$unix_path"
17784   fi
17785 
17786 
17787     new_path=`$WHICH "$new_path" 2> /dev/null`
17788     # bat and cmd files are not always considered executable in MSYS causing which
17789     # to not find them
17790     if test "x$new_path" = x \
17791         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17792         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17793       new_path="$path"
17794 
17795   windows_path="$new_path"
17796   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17797     unix_path=`$CYGPATH -u "$windows_path"`
17798     new_path="$unix_path"
17799   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17800     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17801     new_path="$unix_path"
17802   fi
17803 
17804     fi
17805 
17806     if test "x$new_path" = x; then
17807       # It's still not found. Now this is an unrecoverable error.
17808       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17809 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17810       has_space=`$ECHO "$complete" | $GREP " "`
17811       if test "x$has_space" != x; then
17812         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
17813 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
17814       fi
17815       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17816     fi
17817   fi
17818 
17819   # Now new_path has a complete unix path to the binary
17820   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
17821     # Keep paths in /bin as-is, but remove trailing .exe if any
17822     new_path="${new_path/%.exe/}"
17823     # Do not save /bin paths to all_fixpath_prefixes!
17824   else
17825     # Not in mixed or Windows style, start by that.
17826     new_path=`cmd //c echo $new_path`
17827 
17828   input_path="$new_path"
17829   # Check if we need to convert this using DOS-style short mode. If the path
17830   # contains just simple characters, use it. Otherwise (spaces, weird characters),
17831   # take no chances and rewrite it.
17832   # Note: m4 eats our [], so we need to use [ and ] instead.
17833   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
17834   if test "x$has_forbidden_chars" != x; then
17835     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
17836     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
17837   fi
17838 
17839     # Output is in $new_path
17840 
17841   windows_path="$new_path"
17842   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17843     unix_path=`$CYGPATH -u "$windows_path"`
17844     new_path="$unix_path"
17845   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17846     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17847     new_path="$unix_path"
17848   fi
17849 
17850     # remove trailing .exe if any
17851     new_path="${new_path/%.exe/}"
17852 
17853     # Save the first 10 bytes of this path to the storage, so fixpath can work.
17854     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
17855   fi
17856 
17857     else
17858       # We're on a unix platform. Hooray! :)
17859       # First separate the path from the arguments. This will split at the first
17860       # space.
17861       complete="$FOUND_MAKE"
17862       path="${complete%% *}"
17863       tmp="$complete EOL"
17864       arguments="${tmp#* }"
17865 
17866       # Cannot rely on the command "which" here since it doesn't always work.
17867       is_absolute_path=`$ECHO "$path" | $GREP ^/`
17868       if test -z "$is_absolute_path"; then
17869         # Path to executable is not absolute. Find it.
17870         IFS_save="$IFS"
17871         IFS=:
17872         for p in $PATH; do
17873           if test -f "$p/$path" && test -x "$p/$path"; then
17874             new_path="$p/$path"
17875             break
17876           fi
17877         done
17878         IFS="$IFS_save"
17879       else
17880         # This is an absolute path, we can use it without further modifications.
17881         new_path="$path"
17882       fi
17883 
17884       if test "x$new_path" = x; then
17885         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17886 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17887         has_space=`$ECHO "$complete" | $GREP " "`
17888         if test "x$has_space" != x; then
17889           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
17890 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
17891         fi
17892         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17893       fi
17894     fi
17895 
17896     # Now join together the path and the arguments once again
17897     if test "x$arguments" != xEOL; then
17898       new_complete="$new_path ${arguments% *}"
17899     else
17900       new_complete="$new_path"
17901     fi
17902 
17903     if test "x$complete" != "x$new_complete"; then
17904       FOUND_MAKE="$new_complete"
17905       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
17906 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
17907     fi
17908   fi
17909 
17910         fi
17911       fi
17912     fi
17913   fi
17914 
17915 
17916     if test "x$FOUND_MAKE" = x; then
17917       for ac_prog in make
17918 do
17919   # Extract the first word of "$ac_prog", so it can be a program name with args.
17920 set dummy $ac_prog; ac_word=$2
17921 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17922 $as_echo_n "checking for $ac_word... " >&6; }
17923 if ${ac_cv_path_CHECK_MAKE+:} false; then :
17924   $as_echo_n "(cached) " >&6
17925 else
17926   case $CHECK_MAKE in
17927   [\\/]* | ?:[\\/]*)
17928   ac_cv_path_CHECK_MAKE="$CHECK_MAKE" # Let the user override the test with a path.
17929   ;;
17930   *)
17931   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17932 for as_dir in $PATH
17933 do
17934   IFS=$as_save_IFS
17935   test -z "$as_dir" && as_dir=.
17936     for ac_exec_ext in '' $ac_executable_extensions; do
17937   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17938     ac_cv_path_CHECK_MAKE="$as_dir/$ac_word$ac_exec_ext"
17939     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17940     break 2
17941   fi
17942 done
17943   done
17944 IFS=$as_save_IFS
17945 
17946   ;;
17947 esac
17948 fi
17949 CHECK_MAKE=$ac_cv_path_CHECK_MAKE
17950 if test -n "$CHECK_MAKE"; then
17951   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_MAKE" >&5
17952 $as_echo "$CHECK_MAKE" >&6; }
17953 else
17954   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17955 $as_echo "no" >&6; }
17956 fi
17957 
17958 
17959   test -n "$CHECK_MAKE" && break
17960 done
17961 
17962 
17963   MAKE_CANDIDATE=""$CHECK_MAKE""
17964   DESCRIPTION="make in PATH"
17965 
17966   # On Cygwin, we require a newer version of make than on other platforms
17967   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17968     MAKE_VERSION_EXPR="-e 4\."
17969     MAKE_REQUIRED_VERSION="4.0"
17970    else
17971     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
17972     MAKE_REQUIRED_VERSION="3.81"
17973   fi
17974 
17975   if test "x$MAKE_CANDIDATE" != x; then
17976     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
17977 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
17978     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
17979     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
17980     if test "x$IS_GNU_MAKE" = x; then
17981       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
17982 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
17983     else
17984       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
17985       if test "x$IS_MODERN_MAKE" = x; then
17986         { $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
17987 $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;}
17988       else
17989         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
17990           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17991             MAKE_EXPECTED_ENV='cygwin'
17992           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17993             MAKE_EXPECTED_ENV='msys'
17994           else
17995             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
17996           fi
17997           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
17998           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
17999         else
18000           # Not relevant for non-Windows
18001           IS_MAKE_CORRECT_ENV=true
18002         fi
18003         if test "x$IS_MAKE_CORRECT_ENV" = x; then
18004           { $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
18005 $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;}
18006         else
18007           FOUND_MAKE=$MAKE_CANDIDATE
18008 
18009   # Only process if variable expands to non-empty
18010 
18011   if test "x$FOUND_MAKE" != x; then
18012     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18013 
18014   # First separate the path from the arguments. This will split at the first
18015   # space.
18016   complete="$FOUND_MAKE"
18017   path="${complete%% *}"
18018   tmp="$complete EOL"
18019   arguments="${tmp#* }"
18020 
18021   # Input might be given as Windows format, start by converting to
18022   # unix format.
18023   new_path=`$CYGPATH -u "$path"`
18024 
18025   # Now try to locate executable using which
18026   new_path=`$WHICH "$new_path" 2> /dev/null`
18027   # bat and cmd files are not always considered executable in cygwin causing which
18028   # to not find them
18029   if test "x$new_path" = x \
18030       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18031       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18032     new_path=`$CYGPATH -u "$path"`
18033   fi
18034   if test "x$new_path" = x; then
18035     # Oops. Which didn't find the executable.
18036     # The splitting of arguments from the executable at a space might have been incorrect,
18037     # since paths with space are more likely in Windows. Give it another try with the whole
18038     # argument.
18039     path="$complete"
18040     arguments="EOL"
18041     new_path=`$CYGPATH -u "$path"`
18042     new_path=`$WHICH "$new_path" 2> /dev/null`
18043     # bat and cmd files are not always considered executable in cygwin causing which
18044     # to not find them
18045     if test "x$new_path" = x \
18046         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18047         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18048       new_path=`$CYGPATH -u "$path"`
18049     fi
18050     if test "x$new_path" = x; then
18051       # It's still not found. Now this is an unrecoverable error.
18052       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18053 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18054       has_space=`$ECHO "$complete" | $GREP " "`
18055       if test "x$has_space" != x; then
18056         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
18057 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
18058       fi
18059       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18060     fi
18061   fi
18062 
18063   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
18064   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
18065   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
18066   # "foo.exe" is OK but "foo" is an error.
18067   #
18068   # This test is therefore slightly more accurate than "test -f" to check for file presence.
18069   # It is also a way to make sure we got the proper file name for the real test later on.
18070   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
18071   if test "x$test_shortpath" = x; then
18072     # Short path failed, file does not exist as specified.
18073     # Try adding .exe or .cmd
18074     if test -f "${new_path}.exe"; then
18075       input_to_shortpath="${new_path}.exe"
18076     elif test -f "${new_path}.cmd"; then
18077       input_to_shortpath="${new_path}.cmd"
18078     else
18079       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
18080 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
18081       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
18082 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
18083       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18084     fi
18085   else
18086     input_to_shortpath="$new_path"
18087   fi
18088 
18089   # Call helper function which possibly converts this using DOS-style short mode.
18090   # If so, the updated path is stored in $new_path.
18091   new_path="$input_to_shortpath"
18092 
18093   input_path="$input_to_shortpath"
18094   # Check if we need to convert this using DOS-style short mode. If the path
18095   # contains just simple characters, use it. Otherwise (spaces, weird characters),
18096   # take no chances and rewrite it.
18097   # Note: m4 eats our [], so we need to use [ and ] instead.
18098   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
18099   if test "x$has_forbidden_chars" != x; then
18100     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
18101     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
18102     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
18103     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
18104       # Going to short mode and back again did indeed matter. Since short mode is
18105       # case insensitive, let's make it lowercase to improve readability.
18106       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
18107       # Now convert it back to Unix-style (cygpath)
18108       input_path=`$CYGPATH -u "$shortmode_path"`
18109       new_path="$input_path"
18110     fi
18111   fi
18112 
18113   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
18114   if test "x$test_cygdrive_prefix" = x; then
18115     # As a simple fix, exclude /usr/bin since it's not a real path.
18116     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
18117       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
18118       # a path prefixed by /cygdrive for fixpath to work.
18119       new_path="$CYGWIN_ROOT_PATH$input_path"
18120     fi
18121   fi
18122 
18123   # remove trailing .exe if any
18124   new_path="${new_path/%.exe/}"
18125 
18126     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18127 
18128   # First separate the path from the arguments. This will split at the first
18129   # space.
18130   complete="$FOUND_MAKE"
18131   path="${complete%% *}"
18132   tmp="$complete EOL"
18133   arguments="${tmp#* }"
18134 
18135   # Input might be given as Windows format, start by converting to
18136   # unix format.
18137   new_path="$path"
18138 
18139   windows_path="$new_path"
18140   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18141     unix_path=`$CYGPATH -u "$windows_path"`
18142     new_path="$unix_path"
18143   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18144     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18145     new_path="$unix_path"
18146   fi
18147 
18148 
18149   # Now try to locate executable using which
18150   new_path=`$WHICH "$new_path" 2> /dev/null`
18151 
18152   if test "x$new_path" = x; then
18153     # Oops. Which didn't find the executable.
18154     # The splitting of arguments from the executable at a space might have been incorrect,
18155     # since paths with space are more likely in Windows. Give it another try with the whole
18156     # argument.
18157     path="$complete"
18158     arguments="EOL"
18159     new_path="$path"
18160 
18161   windows_path="$new_path"
18162   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18163     unix_path=`$CYGPATH -u "$windows_path"`
18164     new_path="$unix_path"
18165   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18166     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18167     new_path="$unix_path"
18168   fi
18169 
18170 
18171     new_path=`$WHICH "$new_path" 2> /dev/null`
18172     # bat and cmd files are not always considered executable in MSYS causing which
18173     # to not find them
18174     if test "x$new_path" = x \
18175         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18176         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18177       new_path="$path"
18178 
18179   windows_path="$new_path"
18180   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18181     unix_path=`$CYGPATH -u "$windows_path"`
18182     new_path="$unix_path"
18183   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18184     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18185     new_path="$unix_path"
18186   fi
18187 
18188     fi
18189 
18190     if test "x$new_path" = x; then
18191       # It's still not found. Now this is an unrecoverable error.
18192       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18193 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18194       has_space=`$ECHO "$complete" | $GREP " "`
18195       if test "x$has_space" != x; then
18196         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
18197 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
18198       fi
18199       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18200     fi
18201   fi
18202 
18203   # Now new_path has a complete unix path to the binary
18204   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
18205     # Keep paths in /bin as-is, but remove trailing .exe if any
18206     new_path="${new_path/%.exe/}"
18207     # Do not save /bin paths to all_fixpath_prefixes!
18208   else
18209     # Not in mixed or Windows style, start by that.
18210     new_path=`cmd //c echo $new_path`
18211 
18212   input_path="$new_path"
18213   # Check if we need to convert this using DOS-style short mode. If the path
18214   # contains just simple characters, use it. Otherwise (spaces, weird characters),
18215   # take no chances and rewrite it.
18216   # Note: m4 eats our [], so we need to use [ and ] instead.
18217   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
18218   if test "x$has_forbidden_chars" != x; then
18219     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
18220     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
18221   fi
18222 
18223     # Output is in $new_path
18224 
18225   windows_path="$new_path"
18226   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18227     unix_path=`$CYGPATH -u "$windows_path"`
18228     new_path="$unix_path"
18229   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18230     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18231     new_path="$unix_path"
18232   fi
18233 
18234     # remove trailing .exe if any
18235     new_path="${new_path/%.exe/}"
18236 
18237     # Save the first 10 bytes of this path to the storage, so fixpath can work.
18238     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
18239   fi
18240 
18241     else
18242       # We're on a unix platform. Hooray! :)
18243       # First separate the path from the arguments. This will split at the first
18244       # space.
18245       complete="$FOUND_MAKE"
18246       path="${complete%% *}"
18247       tmp="$complete EOL"
18248       arguments="${tmp#* }"
18249 
18250       # Cannot rely on the command "which" here since it doesn't always work.
18251       is_absolute_path=`$ECHO "$path" | $GREP ^/`
18252       if test -z "$is_absolute_path"; then
18253         # Path to executable is not absolute. Find it.
18254         IFS_save="$IFS"
18255         IFS=:
18256         for p in $PATH; do
18257           if test -f "$p/$path" && test -x "$p/$path"; then
18258             new_path="$p/$path"
18259             break
18260           fi
18261         done
18262         IFS="$IFS_save"
18263       else
18264         # This is an absolute path, we can use it without further modifications.
18265         new_path="$path"
18266       fi
18267 
18268       if test "x$new_path" = x; then
18269         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18270 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18271         has_space=`$ECHO "$complete" | $GREP " "`
18272         if test "x$has_space" != x; then
18273           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
18274 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
18275         fi
18276         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18277       fi
18278     fi
18279 
18280     # Now join together the path and the arguments once again
18281     if test "x$arguments" != xEOL; then
18282       new_complete="$new_path ${arguments% *}"
18283     else
18284       new_complete="$new_path"
18285     fi
18286 
18287     if test "x$complete" != "x$new_complete"; then
18288       FOUND_MAKE="$new_complete"
18289       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
18290 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
18291     fi
18292   fi
18293 
18294         fi
18295       fi
18296     fi
18297   fi
18298 
18299     fi
18300 
18301     if test "x$FOUND_MAKE" = x; then
18302       if test "x$TOOLCHAIN_PATH" != x; then
18303         # We have a toolchain path, check that as well before giving up.
18304         OLD_PATH=$PATH
18305         PATH=$TOOLCHAIN_PATH:$PATH
18306         for ac_prog in gmake
18307 do
18308   # Extract the first word of "$ac_prog", so it can be a program name with args.
18309 set dummy $ac_prog; ac_word=$2
18310 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18311 $as_echo_n "checking for $ac_word... " >&6; }
18312 if ${ac_cv_path_CHECK_TOOLSDIR_GMAKE+:} false; then :
18313   $as_echo_n "(cached) " >&6
18314 else
18315   case $CHECK_TOOLSDIR_GMAKE in
18316   [\\/]* | ?:[\\/]*)
18317   ac_cv_path_CHECK_TOOLSDIR_GMAKE="$CHECK_TOOLSDIR_GMAKE" # Let the user override the test with a path.
18318   ;;
18319   *)
18320   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18321 for as_dir in $PATH
18322 do
18323   IFS=$as_save_IFS
18324   test -z "$as_dir" && as_dir=.
18325     for ac_exec_ext in '' $ac_executable_extensions; do
18326   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18327     ac_cv_path_CHECK_TOOLSDIR_GMAKE="$as_dir/$ac_word$ac_exec_ext"
18328     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18329     break 2
18330   fi
18331 done
18332   done
18333 IFS=$as_save_IFS
18334 
18335   ;;
18336 esac
18337 fi
18338 CHECK_TOOLSDIR_GMAKE=$ac_cv_path_CHECK_TOOLSDIR_GMAKE
18339 if test -n "$CHECK_TOOLSDIR_GMAKE"; then
18340   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_GMAKE" >&5
18341 $as_echo "$CHECK_TOOLSDIR_GMAKE" >&6; }
18342 else
18343   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18344 $as_echo "no" >&6; }
18345 fi
18346 
18347 
18348   test -n "$CHECK_TOOLSDIR_GMAKE" && break
18349 done
18350 
18351 
18352   MAKE_CANDIDATE=""$CHECK_TOOLSDIR_GMAKE""
18353   DESCRIPTION="gmake in tools-dir"
18354 
18355   # On Cygwin, we require a newer version of make than on other platforms
18356   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18357     MAKE_VERSION_EXPR="-e 4\."
18358     MAKE_REQUIRED_VERSION="4.0"
18359    else
18360     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
18361     MAKE_REQUIRED_VERSION="3.81"
18362   fi
18363 
18364   if test "x$MAKE_CANDIDATE" != x; then
18365     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
18366 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
18367     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
18368     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
18369     if test "x$IS_GNU_MAKE" = x; then
18370       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
18371 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
18372     else
18373       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
18374       if test "x$IS_MODERN_MAKE" = x; then
18375         { $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
18376 $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;}
18377       else
18378         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
18379           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18380             MAKE_EXPECTED_ENV='cygwin'
18381           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18382             MAKE_EXPECTED_ENV='msys'
18383           else
18384             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
18385           fi
18386           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
18387           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
18388         else
18389           # Not relevant for non-Windows
18390           IS_MAKE_CORRECT_ENV=true
18391         fi
18392         if test "x$IS_MAKE_CORRECT_ENV" = x; then
18393           { $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
18394 $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;}
18395         else
18396           FOUND_MAKE=$MAKE_CANDIDATE
18397 
18398   # Only process if variable expands to non-empty
18399 
18400   if test "x$FOUND_MAKE" != x; then
18401     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18402 
18403   # First separate the path from the arguments. This will split at the first
18404   # space.
18405   complete="$FOUND_MAKE"
18406   path="${complete%% *}"
18407   tmp="$complete EOL"
18408   arguments="${tmp#* }"
18409 
18410   # Input might be given as Windows format, start by converting to
18411   # unix format.
18412   new_path=`$CYGPATH -u "$path"`
18413 
18414   # Now try to locate executable using which
18415   new_path=`$WHICH "$new_path" 2> /dev/null`
18416   # bat and cmd files are not always considered executable in cygwin causing which
18417   # to not find them
18418   if test "x$new_path" = x \
18419       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18420       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18421     new_path=`$CYGPATH -u "$path"`
18422   fi
18423   if test "x$new_path" = x; then
18424     # Oops. Which didn't find the executable.
18425     # The splitting of arguments from the executable at a space might have been incorrect,
18426     # since paths with space are more likely in Windows. Give it another try with the whole
18427     # argument.
18428     path="$complete"
18429     arguments="EOL"
18430     new_path=`$CYGPATH -u "$path"`
18431     new_path=`$WHICH "$new_path" 2> /dev/null`
18432     # bat and cmd files are not always considered executable in cygwin causing which
18433     # to not find them
18434     if test "x$new_path" = x \
18435         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18436         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18437       new_path=`$CYGPATH -u "$path"`
18438     fi
18439     if test "x$new_path" = x; then
18440       # It's still not found. Now this is an unrecoverable error.
18441       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18442 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18443       has_space=`$ECHO "$complete" | $GREP " "`
18444       if test "x$has_space" != x; then
18445         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
18446 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
18447       fi
18448       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18449     fi
18450   fi
18451 
18452   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
18453   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
18454   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
18455   # "foo.exe" is OK but "foo" is an error.
18456   #
18457   # This test is therefore slightly more accurate than "test -f" to check for file presence.
18458   # It is also a way to make sure we got the proper file name for the real test later on.
18459   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
18460   if test "x$test_shortpath" = x; then
18461     # Short path failed, file does not exist as specified.
18462     # Try adding .exe or .cmd
18463     if test -f "${new_path}.exe"; then
18464       input_to_shortpath="${new_path}.exe"
18465     elif test -f "${new_path}.cmd"; then
18466       input_to_shortpath="${new_path}.cmd"
18467     else
18468       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
18469 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
18470       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
18471 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
18472       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18473     fi
18474   else
18475     input_to_shortpath="$new_path"
18476   fi
18477 
18478   # Call helper function which possibly converts this using DOS-style short mode.
18479   # If so, the updated path is stored in $new_path.
18480   new_path="$input_to_shortpath"
18481 
18482   input_path="$input_to_shortpath"
18483   # Check if we need to convert this using DOS-style short mode. If the path
18484   # contains just simple characters, use it. Otherwise (spaces, weird characters),
18485   # take no chances and rewrite it.
18486   # Note: m4 eats our [], so we need to use [ and ] instead.
18487   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
18488   if test "x$has_forbidden_chars" != x; then
18489     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
18490     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
18491     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
18492     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
18493       # Going to short mode and back again did indeed matter. Since short mode is
18494       # case insensitive, let's make it lowercase to improve readability.
18495       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
18496       # Now convert it back to Unix-style (cygpath)
18497       input_path=`$CYGPATH -u "$shortmode_path"`
18498       new_path="$input_path"
18499     fi
18500   fi
18501 
18502   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
18503   if test "x$test_cygdrive_prefix" = x; then
18504     # As a simple fix, exclude /usr/bin since it's not a real path.
18505     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
18506       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
18507       # a path prefixed by /cygdrive for fixpath to work.
18508       new_path="$CYGWIN_ROOT_PATH$input_path"
18509     fi
18510   fi
18511 
18512   # remove trailing .exe if any
18513   new_path="${new_path/%.exe/}"
18514 
18515     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18516 
18517   # First separate the path from the arguments. This will split at the first
18518   # space.
18519   complete="$FOUND_MAKE"
18520   path="${complete%% *}"
18521   tmp="$complete EOL"
18522   arguments="${tmp#* }"
18523 
18524   # Input might be given as Windows format, start by converting to
18525   # unix format.
18526   new_path="$path"
18527 
18528   windows_path="$new_path"
18529   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18530     unix_path=`$CYGPATH -u "$windows_path"`
18531     new_path="$unix_path"
18532   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18533     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18534     new_path="$unix_path"
18535   fi
18536 
18537 
18538   # Now try to locate executable using which
18539   new_path=`$WHICH "$new_path" 2> /dev/null`
18540 
18541   if test "x$new_path" = x; then
18542     # Oops. Which didn't find the executable.
18543     # The splitting of arguments from the executable at a space might have been incorrect,
18544     # since paths with space are more likely in Windows. Give it another try with the whole
18545     # argument.
18546     path="$complete"
18547     arguments="EOL"
18548     new_path="$path"
18549 
18550   windows_path="$new_path"
18551   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18552     unix_path=`$CYGPATH -u "$windows_path"`
18553     new_path="$unix_path"
18554   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18555     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18556     new_path="$unix_path"
18557   fi
18558 
18559 
18560     new_path=`$WHICH "$new_path" 2> /dev/null`
18561     # bat and cmd files are not always considered executable in MSYS causing which
18562     # to not find them
18563     if test "x$new_path" = x \
18564         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18565         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18566       new_path="$path"
18567 
18568   windows_path="$new_path"
18569   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18570     unix_path=`$CYGPATH -u "$windows_path"`
18571     new_path="$unix_path"
18572   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18573     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18574     new_path="$unix_path"
18575   fi
18576 
18577     fi
18578 
18579     if test "x$new_path" = x; then
18580       # It's still not found. Now this is an unrecoverable error.
18581       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18582 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18583       has_space=`$ECHO "$complete" | $GREP " "`
18584       if test "x$has_space" != x; then
18585         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
18586 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
18587       fi
18588       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18589     fi
18590   fi
18591 
18592   # Now new_path has a complete unix path to the binary
18593   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
18594     # Keep paths in /bin as-is, but remove trailing .exe if any
18595     new_path="${new_path/%.exe/}"
18596     # Do not save /bin paths to all_fixpath_prefixes!
18597   else
18598     # Not in mixed or Windows style, start by that.
18599     new_path=`cmd //c echo $new_path`
18600 
18601   input_path="$new_path"
18602   # Check if we need to convert this using DOS-style short mode. If the path
18603   # contains just simple characters, use it. Otherwise (spaces, weird characters),
18604   # take no chances and rewrite it.
18605   # Note: m4 eats our [], so we need to use [ and ] instead.
18606   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
18607   if test "x$has_forbidden_chars" != x; then
18608     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
18609     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
18610   fi
18611 
18612     # Output is in $new_path
18613 
18614   windows_path="$new_path"
18615   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18616     unix_path=`$CYGPATH -u "$windows_path"`
18617     new_path="$unix_path"
18618   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18619     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18620     new_path="$unix_path"
18621   fi
18622 
18623     # remove trailing .exe if any
18624     new_path="${new_path/%.exe/}"
18625 
18626     # Save the first 10 bytes of this path to the storage, so fixpath can work.
18627     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
18628   fi
18629 
18630     else
18631       # We're on a unix platform. Hooray! :)
18632       # First separate the path from the arguments. This will split at the first
18633       # space.
18634       complete="$FOUND_MAKE"
18635       path="${complete%% *}"
18636       tmp="$complete EOL"
18637       arguments="${tmp#* }"
18638 
18639       # Cannot rely on the command "which" here since it doesn't always work.
18640       is_absolute_path=`$ECHO "$path" | $GREP ^/`
18641       if test -z "$is_absolute_path"; then
18642         # Path to executable is not absolute. Find it.
18643         IFS_save="$IFS"
18644         IFS=:
18645         for p in $PATH; do
18646           if test -f "$p/$path" && test -x "$p/$path"; then
18647             new_path="$p/$path"
18648             break
18649           fi
18650         done
18651         IFS="$IFS_save"
18652       else
18653         # This is an absolute path, we can use it without further modifications.
18654         new_path="$path"
18655       fi
18656 
18657       if test "x$new_path" = x; then
18658         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18659 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18660         has_space=`$ECHO "$complete" | $GREP " "`
18661         if test "x$has_space" != x; then
18662           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
18663 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
18664         fi
18665         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18666       fi
18667     fi
18668 
18669     # Now join together the path and the arguments once again
18670     if test "x$arguments" != xEOL; then
18671       new_complete="$new_path ${arguments% *}"
18672     else
18673       new_complete="$new_path"
18674     fi
18675 
18676     if test "x$complete" != "x$new_complete"; then
18677       FOUND_MAKE="$new_complete"
18678       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
18679 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
18680     fi
18681   fi
18682 
18683         fi
18684       fi
18685     fi
18686   fi
18687 
18688         if test "x$FOUND_MAKE" = x; then
18689           for ac_prog in make
18690 do
18691   # Extract the first word of "$ac_prog", so it can be a program name with args.
18692 set dummy $ac_prog; ac_word=$2
18693 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18694 $as_echo_n "checking for $ac_word... " >&6; }
18695 if ${ac_cv_path_CHECK_TOOLSDIR_MAKE+:} false; then :
18696   $as_echo_n "(cached) " >&6
18697 else
18698   case $CHECK_TOOLSDIR_MAKE in
18699   [\\/]* | ?:[\\/]*)
18700   ac_cv_path_CHECK_TOOLSDIR_MAKE="$CHECK_TOOLSDIR_MAKE" # Let the user override the test with a path.
18701   ;;
18702   *)
18703   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18704 for as_dir in $PATH
18705 do
18706   IFS=$as_save_IFS
18707   test -z "$as_dir" && as_dir=.
18708     for ac_exec_ext in '' $ac_executable_extensions; do
18709   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18710     ac_cv_path_CHECK_TOOLSDIR_MAKE="$as_dir/$ac_word$ac_exec_ext"
18711     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18712     break 2
18713   fi
18714 done
18715   done
18716 IFS=$as_save_IFS
18717 
18718   ;;
18719 esac
18720 fi
18721 CHECK_TOOLSDIR_MAKE=$ac_cv_path_CHECK_TOOLSDIR_MAKE
18722 if test -n "$CHECK_TOOLSDIR_MAKE"; then
18723   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_MAKE" >&5
18724 $as_echo "$CHECK_TOOLSDIR_MAKE" >&6; }
18725 else
18726   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18727 $as_echo "no" >&6; }
18728 fi
18729 
18730 
18731   test -n "$CHECK_TOOLSDIR_MAKE" && break
18732 done
18733 
18734 
18735   MAKE_CANDIDATE=""$CHECK_TOOLSDIR_MAKE""
18736   DESCRIPTION="make in tools-dir"
18737 
18738   # On Cygwin, we require a newer version of make than on other platforms
18739   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18740     MAKE_VERSION_EXPR="-e 4\."
18741     MAKE_REQUIRED_VERSION="4.0"
18742    else
18743     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
18744     MAKE_REQUIRED_VERSION="3.81"
18745   fi
18746 
18747   if test "x$MAKE_CANDIDATE" != x; then
18748     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
18749 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
18750     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
18751     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
18752     if test "x$IS_GNU_MAKE" = x; then
18753       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
18754 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
18755     else
18756       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
18757       if test "x$IS_MODERN_MAKE" = x; then
18758         { $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
18759 $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;}
18760       else
18761         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
18762           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18763             MAKE_EXPECTED_ENV='cygwin'
18764           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18765             MAKE_EXPECTED_ENV='msys'
18766           else
18767             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
18768           fi
18769           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
18770           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
18771         else
18772           # Not relevant for non-Windows
18773           IS_MAKE_CORRECT_ENV=true
18774         fi
18775         if test "x$IS_MAKE_CORRECT_ENV" = x; then
18776           { $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
18777 $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;}
18778         else
18779           FOUND_MAKE=$MAKE_CANDIDATE
18780 
18781   # Only process if variable expands to non-empty
18782 
18783   if test "x$FOUND_MAKE" != x; then
18784     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18785 
18786   # First separate the path from the arguments. This will split at the first
18787   # space.
18788   complete="$FOUND_MAKE"
18789   path="${complete%% *}"
18790   tmp="$complete EOL"
18791   arguments="${tmp#* }"
18792 
18793   # Input might be given as Windows format, start by converting to
18794   # unix format.
18795   new_path=`$CYGPATH -u "$path"`
18796 
18797   # Now try to locate executable using which
18798   new_path=`$WHICH "$new_path" 2> /dev/null`
18799   # bat and cmd files are not always considered executable in cygwin causing which
18800   # to not find them
18801   if test "x$new_path" = x \
18802       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18803       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18804     new_path=`$CYGPATH -u "$path"`
18805   fi
18806   if test "x$new_path" = x; then
18807     # Oops. Which didn't find the executable.
18808     # The splitting of arguments from the executable at a space might have been incorrect,
18809     # since paths with space are more likely in Windows. Give it another try with the whole
18810     # argument.
18811     path="$complete"
18812     arguments="EOL"
18813     new_path=`$CYGPATH -u "$path"`
18814     new_path=`$WHICH "$new_path" 2> /dev/null`
18815     # bat and cmd files are not always considered executable in cygwin causing which
18816     # to not find them
18817     if test "x$new_path" = x \
18818         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18819         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18820       new_path=`$CYGPATH -u "$path"`
18821     fi
18822     if test "x$new_path" = x; then
18823       # It's still not found. Now this is an unrecoverable error.
18824       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18825 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18826       has_space=`$ECHO "$complete" | $GREP " "`
18827       if test "x$has_space" != x; then
18828         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
18829 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
18830       fi
18831       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18832     fi
18833   fi
18834 
18835   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
18836   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
18837   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
18838   # "foo.exe" is OK but "foo" is an error.
18839   #
18840   # This test is therefore slightly more accurate than "test -f" to check for file presence.
18841   # It is also a way to make sure we got the proper file name for the real test later on.
18842   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
18843   if test "x$test_shortpath" = x; then
18844     # Short path failed, file does not exist as specified.
18845     # Try adding .exe or .cmd
18846     if test -f "${new_path}.exe"; then
18847       input_to_shortpath="${new_path}.exe"
18848     elif test -f "${new_path}.cmd"; then
18849       input_to_shortpath="${new_path}.cmd"
18850     else
18851       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
18852 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
18853       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
18854 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
18855       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18856     fi
18857   else
18858     input_to_shortpath="$new_path"
18859   fi
18860 
18861   # Call helper function which possibly converts this using DOS-style short mode.
18862   # If so, the updated path is stored in $new_path.
18863   new_path="$input_to_shortpath"
18864 
18865   input_path="$input_to_shortpath"
18866   # Check if we need to convert this using DOS-style short mode. If the path
18867   # contains just simple characters, use it. Otherwise (spaces, weird characters),
18868   # take no chances and rewrite it.
18869   # Note: m4 eats our [], so we need to use [ and ] instead.
18870   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
18871   if test "x$has_forbidden_chars" != x; then
18872     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
18873     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
18874     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
18875     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
18876       # Going to short mode and back again did indeed matter. Since short mode is
18877       # case insensitive, let's make it lowercase to improve readability.
18878       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
18879       # Now convert it back to Unix-style (cygpath)
18880       input_path=`$CYGPATH -u "$shortmode_path"`
18881       new_path="$input_path"
18882     fi
18883   fi
18884 
18885   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
18886   if test "x$test_cygdrive_prefix" = x; then
18887     # As a simple fix, exclude /usr/bin since it's not a real path.
18888     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
18889       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
18890       # a path prefixed by /cygdrive for fixpath to work.
18891       new_path="$CYGWIN_ROOT_PATH$input_path"
18892     fi
18893   fi
18894 
18895   # remove trailing .exe if any
18896   new_path="${new_path/%.exe/}"
18897 
18898     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18899 
18900   # First separate the path from the arguments. This will split at the first
18901   # space.
18902   complete="$FOUND_MAKE"
18903   path="${complete%% *}"
18904   tmp="$complete EOL"
18905   arguments="${tmp#* }"
18906 
18907   # Input might be given as Windows format, start by converting to
18908   # unix format.
18909   new_path="$path"
18910 
18911   windows_path="$new_path"
18912   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18913     unix_path=`$CYGPATH -u "$windows_path"`
18914     new_path="$unix_path"
18915   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18916     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18917     new_path="$unix_path"
18918   fi
18919 
18920 
18921   # Now try to locate executable using which
18922   new_path=`$WHICH "$new_path" 2> /dev/null`
18923 
18924   if test "x$new_path" = x; then
18925     # Oops. Which didn't find the executable.
18926     # The splitting of arguments from the executable at a space might have been incorrect,
18927     # since paths with space are more likely in Windows. Give it another try with the whole
18928     # argument.
18929     path="$complete"
18930     arguments="EOL"
18931     new_path="$path"
18932 
18933   windows_path="$new_path"
18934   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18935     unix_path=`$CYGPATH -u "$windows_path"`
18936     new_path="$unix_path"
18937   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18938     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18939     new_path="$unix_path"
18940   fi
18941 
18942 
18943     new_path=`$WHICH "$new_path" 2> /dev/null`
18944     # bat and cmd files are not always considered executable in MSYS causing which
18945     # to not find them
18946     if test "x$new_path" = x \
18947         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18948         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18949       new_path="$path"
18950 
18951   windows_path="$new_path"
18952   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18953     unix_path=`$CYGPATH -u "$windows_path"`
18954     new_path="$unix_path"
18955   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18956     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18957     new_path="$unix_path"
18958   fi
18959 
18960     fi
18961 
18962     if test "x$new_path" = x; then
18963       # It's still not found. Now this is an unrecoverable error.
18964       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18965 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18966       has_space=`$ECHO "$complete" | $GREP " "`
18967       if test "x$has_space" != x; then
18968         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
18969 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
18970       fi
18971       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18972     fi
18973   fi
18974 
18975   # Now new_path has a complete unix path to the binary
18976   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
18977     # Keep paths in /bin as-is, but remove trailing .exe if any
18978     new_path="${new_path/%.exe/}"
18979     # Do not save /bin paths to all_fixpath_prefixes!
18980   else
18981     # Not in mixed or Windows style, start by that.
18982     new_path=`cmd //c echo $new_path`
18983 
18984   input_path="$new_path"
18985   # Check if we need to convert this using DOS-style short mode. If the path
18986   # contains just simple characters, use it. Otherwise (spaces, weird characters),
18987   # take no chances and rewrite it.
18988   # Note: m4 eats our [], so we need to use [ and ] instead.
18989   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
18990   if test "x$has_forbidden_chars" != x; then
18991     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
18992     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
18993   fi
18994 
18995     # Output is in $new_path
18996 
18997   windows_path="$new_path"
18998   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18999     unix_path=`$CYGPATH -u "$windows_path"`
19000     new_path="$unix_path"
19001   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19002     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19003     new_path="$unix_path"
19004   fi
19005 
19006     # remove trailing .exe if any
19007     new_path="${new_path/%.exe/}"
19008 
19009     # Save the first 10 bytes of this path to the storage, so fixpath can work.
19010     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
19011   fi
19012 
19013     else
19014       # We're on a unix platform. Hooray! :)
19015       # First separate the path from the arguments. This will split at the first
19016       # space.
19017       complete="$FOUND_MAKE"
19018       path="${complete%% *}"
19019       tmp="$complete EOL"
19020       arguments="${tmp#* }"
19021 
19022       # Cannot rely on the command "which" here since it doesn't always work.
19023       is_absolute_path=`$ECHO "$path" | $GREP ^/`
19024       if test -z "$is_absolute_path"; then
19025         # Path to executable is not absolute. Find it.
19026         IFS_save="$IFS"
19027         IFS=:
19028         for p in $PATH; do
19029           if test -f "$p/$path" && test -x "$p/$path"; then
19030             new_path="$p/$path"
19031             break
19032           fi
19033         done
19034         IFS="$IFS_save"
19035       else
19036         # This is an absolute path, we can use it without further modifications.
19037         new_path="$path"
19038       fi
19039 
19040       if test "x$new_path" = x; then
19041         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19042 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19043         has_space=`$ECHO "$complete" | $GREP " "`
19044         if test "x$has_space" != x; then
19045           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
19046 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
19047         fi
19048         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19049       fi
19050     fi
19051 
19052     # Now join together the path and the arguments once again
19053     if test "x$arguments" != xEOL; then
19054       new_complete="$new_path ${arguments% *}"
19055     else
19056       new_complete="$new_path"
19057     fi
19058 
19059     if test "x$complete" != "x$new_complete"; then
19060       FOUND_MAKE="$new_complete"
19061       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
19062 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
19063     fi
19064   fi
19065 
19066         fi
19067       fi
19068     fi
19069   fi
19070 
19071         fi
19072         PATH=$OLD_PATH
19073       fi
19074     fi
19075 
19076     if test "x$FOUND_MAKE" = x; then
19077       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
19078     fi
19079 
19080   else
19081     # The variable is set, but is it from the command line or the environment?
19082 
19083     # Try to remove the string !MAKE! from our list.
19084     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MAKE!/}
19085     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
19086       # If it failed, the variable was not from the command line. Ignore it,
19087       # but warn the user (except for BASH, which is always set by the calling BASH).
19088       if test "xMAKE" != xBASH; then
19089         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MAKE from the environment. Use command line variables instead." >&5
19090 $as_echo "$as_me: WARNING: Ignoring value of MAKE from the environment. Use command line variables instead." >&2;}
19091       fi
19092       # Try to locate tool using the code snippet
19093 
19094     # Try our hardest to locate a correct version of GNU make
19095     for ac_prog in gmake
19096 do
19097   # Extract the first word of "$ac_prog", so it can be a program name with args.
19098 set dummy $ac_prog; ac_word=$2
19099 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19100 $as_echo_n "checking for $ac_word... " >&6; }
19101 if ${ac_cv_path_CHECK_GMAKE+:} false; then :
19102   $as_echo_n "(cached) " >&6
19103 else
19104   case $CHECK_GMAKE in
19105   [\\/]* | ?:[\\/]*)
19106   ac_cv_path_CHECK_GMAKE="$CHECK_GMAKE" # Let the user override the test with a path.
19107   ;;
19108   *)
19109   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19110 for as_dir in $PATH
19111 do
19112   IFS=$as_save_IFS
19113   test -z "$as_dir" && as_dir=.
19114     for ac_exec_ext in '' $ac_executable_extensions; do
19115   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19116     ac_cv_path_CHECK_GMAKE="$as_dir/$ac_word$ac_exec_ext"
19117     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19118     break 2
19119   fi
19120 done
19121   done
19122 IFS=$as_save_IFS
19123 
19124   ;;
19125 esac
19126 fi
19127 CHECK_GMAKE=$ac_cv_path_CHECK_GMAKE
19128 if test -n "$CHECK_GMAKE"; then
19129   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_GMAKE" >&5
19130 $as_echo "$CHECK_GMAKE" >&6; }
19131 else
19132   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19133 $as_echo "no" >&6; }
19134 fi
19135 
19136 
19137   test -n "$CHECK_GMAKE" && break
19138 done
19139 
19140 
19141   MAKE_CANDIDATE=""$CHECK_GMAKE""
19142   DESCRIPTION="gmake in PATH"
19143 
19144   # On Cygwin, we require a newer version of make than on other platforms
19145   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19146     MAKE_VERSION_EXPR="-e 4\."
19147     MAKE_REQUIRED_VERSION="4.0"
19148    else
19149     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
19150     MAKE_REQUIRED_VERSION="3.81"
19151   fi
19152 
19153   if test "x$MAKE_CANDIDATE" != x; then
19154     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
19155 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
19156     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
19157     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
19158     if test "x$IS_GNU_MAKE" = x; then
19159       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
19160 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
19161     else
19162       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
19163       if test "x$IS_MODERN_MAKE" = x; then
19164         { $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
19165 $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;}
19166       else
19167         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
19168           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19169             MAKE_EXPECTED_ENV='cygwin'
19170           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19171             MAKE_EXPECTED_ENV='msys'
19172           else
19173             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
19174           fi
19175           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
19176           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
19177         else
19178           # Not relevant for non-Windows
19179           IS_MAKE_CORRECT_ENV=true
19180         fi
19181         if test "x$IS_MAKE_CORRECT_ENV" = x; then
19182           { $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
19183 $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;}
19184         else
19185           FOUND_MAKE=$MAKE_CANDIDATE
19186 
19187   # Only process if variable expands to non-empty
19188 
19189   if test "x$FOUND_MAKE" != x; then
19190     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19191 
19192   # First separate the path from the arguments. This will split at the first
19193   # space.
19194   complete="$FOUND_MAKE"
19195   path="${complete%% *}"
19196   tmp="$complete EOL"
19197   arguments="${tmp#* }"
19198 
19199   # Input might be given as Windows format, start by converting to
19200   # unix format.
19201   new_path=`$CYGPATH -u "$path"`
19202 
19203   # Now try to locate executable using which
19204   new_path=`$WHICH "$new_path" 2> /dev/null`
19205   # bat and cmd files are not always considered executable in cygwin causing which
19206   # to not find them
19207   if test "x$new_path" = x \
19208       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19209       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19210     new_path=`$CYGPATH -u "$path"`
19211   fi
19212   if test "x$new_path" = x; then
19213     # Oops. Which didn't find the executable.
19214     # The splitting of arguments from the executable at a space might have been incorrect,
19215     # since paths with space are more likely in Windows. Give it another try with the whole
19216     # argument.
19217     path="$complete"
19218     arguments="EOL"
19219     new_path=`$CYGPATH -u "$path"`
19220     new_path=`$WHICH "$new_path" 2> /dev/null`
19221     # bat and cmd files are not always considered executable in cygwin causing which
19222     # to not find them
19223     if test "x$new_path" = x \
19224         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19225         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19226       new_path=`$CYGPATH -u "$path"`
19227     fi
19228     if test "x$new_path" = x; then
19229       # It's still not found. Now this is an unrecoverable error.
19230       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19231 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19232       has_space=`$ECHO "$complete" | $GREP " "`
19233       if test "x$has_space" != x; then
19234         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
19235 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
19236       fi
19237       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19238     fi
19239   fi
19240 
19241   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
19242   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
19243   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
19244   # "foo.exe" is OK but "foo" is an error.
19245   #
19246   # This test is therefore slightly more accurate than "test -f" to check for file presence.
19247   # It is also a way to make sure we got the proper file name for the real test later on.
19248   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
19249   if test "x$test_shortpath" = x; then
19250     # Short path failed, file does not exist as specified.
19251     # Try adding .exe or .cmd
19252     if test -f "${new_path}.exe"; then
19253       input_to_shortpath="${new_path}.exe"
19254     elif test -f "${new_path}.cmd"; then
19255       input_to_shortpath="${new_path}.cmd"
19256     else
19257       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
19258 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
19259       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
19260 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
19261       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19262     fi
19263   else
19264     input_to_shortpath="$new_path"
19265   fi
19266 
19267   # Call helper function which possibly converts this using DOS-style short mode.
19268   # If so, the updated path is stored in $new_path.
19269   new_path="$input_to_shortpath"
19270 
19271   input_path="$input_to_shortpath"
19272   # Check if we need to convert this using DOS-style short mode. If the path
19273   # contains just simple characters, use it. Otherwise (spaces, weird characters),
19274   # take no chances and rewrite it.
19275   # Note: m4 eats our [], so we need to use [ and ] instead.
19276   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
19277   if test "x$has_forbidden_chars" != x; then
19278     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
19279     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
19280     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
19281     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
19282       # Going to short mode and back again did indeed matter. Since short mode is
19283       # case insensitive, let's make it lowercase to improve readability.
19284       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
19285       # Now convert it back to Unix-style (cygpath)
19286       input_path=`$CYGPATH -u "$shortmode_path"`
19287       new_path="$input_path"
19288     fi
19289   fi
19290 
19291   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
19292   if test "x$test_cygdrive_prefix" = x; then
19293     # As a simple fix, exclude /usr/bin since it's not a real path.
19294     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
19295       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
19296       # a path prefixed by /cygdrive for fixpath to work.
19297       new_path="$CYGWIN_ROOT_PATH$input_path"
19298     fi
19299   fi
19300 
19301   # remove trailing .exe if any
19302   new_path="${new_path/%.exe/}"
19303 
19304     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19305 
19306   # First separate the path from the arguments. This will split at the first
19307   # space.
19308   complete="$FOUND_MAKE"
19309   path="${complete%% *}"
19310   tmp="$complete EOL"
19311   arguments="${tmp#* }"
19312 
19313   # Input might be given as Windows format, start by converting to
19314   # unix format.
19315   new_path="$path"
19316 
19317   windows_path="$new_path"
19318   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19319     unix_path=`$CYGPATH -u "$windows_path"`
19320     new_path="$unix_path"
19321   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19322     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19323     new_path="$unix_path"
19324   fi
19325 
19326 
19327   # Now try to locate executable using which
19328   new_path=`$WHICH "$new_path" 2> /dev/null`
19329 
19330   if test "x$new_path" = x; then
19331     # Oops. Which didn't find the executable.
19332     # The splitting of arguments from the executable at a space might have been incorrect,
19333     # since paths with space are more likely in Windows. Give it another try with the whole
19334     # argument.
19335     path="$complete"
19336     arguments="EOL"
19337     new_path="$path"
19338 
19339   windows_path="$new_path"
19340   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19341     unix_path=`$CYGPATH -u "$windows_path"`
19342     new_path="$unix_path"
19343   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19344     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19345     new_path="$unix_path"
19346   fi
19347 
19348 
19349     new_path=`$WHICH "$new_path" 2> /dev/null`
19350     # bat and cmd files are not always considered executable in MSYS causing which
19351     # to not find them
19352     if test "x$new_path" = x \
19353         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19354         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19355       new_path="$path"
19356 
19357   windows_path="$new_path"
19358   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19359     unix_path=`$CYGPATH -u "$windows_path"`
19360     new_path="$unix_path"
19361   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19362     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19363     new_path="$unix_path"
19364   fi
19365 
19366     fi
19367 
19368     if test "x$new_path" = x; then
19369       # It's still not found. Now this is an unrecoverable error.
19370       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19371 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19372       has_space=`$ECHO "$complete" | $GREP " "`
19373       if test "x$has_space" != x; then
19374         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
19375 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
19376       fi
19377       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19378     fi
19379   fi
19380 
19381   # Now new_path has a complete unix path to the binary
19382   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
19383     # Keep paths in /bin as-is, but remove trailing .exe if any
19384     new_path="${new_path/%.exe/}"
19385     # Do not save /bin paths to all_fixpath_prefixes!
19386   else
19387     # Not in mixed or Windows style, start by that.
19388     new_path=`cmd //c echo $new_path`
19389 
19390   input_path="$new_path"
19391   # Check if we need to convert this using DOS-style short mode. If the path
19392   # contains just simple characters, use it. Otherwise (spaces, weird characters),
19393   # take no chances and rewrite it.
19394   # Note: m4 eats our [], so we need to use [ and ] instead.
19395   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
19396   if test "x$has_forbidden_chars" != x; then
19397     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
19398     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
19399   fi
19400 
19401     # Output is in $new_path
19402 
19403   windows_path="$new_path"
19404   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19405     unix_path=`$CYGPATH -u "$windows_path"`
19406     new_path="$unix_path"
19407   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19408     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19409     new_path="$unix_path"
19410   fi
19411 
19412     # remove trailing .exe if any
19413     new_path="${new_path/%.exe/}"
19414 
19415     # Save the first 10 bytes of this path to the storage, so fixpath can work.
19416     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
19417   fi
19418 
19419     else
19420       # We're on a unix platform. Hooray! :)
19421       # First separate the path from the arguments. This will split at the first
19422       # space.
19423       complete="$FOUND_MAKE"
19424       path="${complete%% *}"
19425       tmp="$complete EOL"
19426       arguments="${tmp#* }"
19427 
19428       # Cannot rely on the command "which" here since it doesn't always work.
19429       is_absolute_path=`$ECHO "$path" | $GREP ^/`
19430       if test -z "$is_absolute_path"; then
19431         # Path to executable is not absolute. Find it.
19432         IFS_save="$IFS"
19433         IFS=:
19434         for p in $PATH; do
19435           if test -f "$p/$path" && test -x "$p/$path"; then
19436             new_path="$p/$path"
19437             break
19438           fi
19439         done
19440         IFS="$IFS_save"
19441       else
19442         # This is an absolute path, we can use it without further modifications.
19443         new_path="$path"
19444       fi
19445 
19446       if test "x$new_path" = x; then
19447         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19448 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19449         has_space=`$ECHO "$complete" | $GREP " "`
19450         if test "x$has_space" != x; then
19451           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
19452 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
19453         fi
19454         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19455       fi
19456     fi
19457 
19458     # Now join together the path and the arguments once again
19459     if test "x$arguments" != xEOL; then
19460       new_complete="$new_path ${arguments% *}"
19461     else
19462       new_complete="$new_path"
19463     fi
19464 
19465     if test "x$complete" != "x$new_complete"; then
19466       FOUND_MAKE="$new_complete"
19467       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
19468 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
19469     fi
19470   fi
19471 
19472         fi
19473       fi
19474     fi
19475   fi
19476 
19477 
19478     if test "x$FOUND_MAKE" = x; then
19479       for ac_prog in make
19480 do
19481   # Extract the first word of "$ac_prog", so it can be a program name with args.
19482 set dummy $ac_prog; ac_word=$2
19483 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19484 $as_echo_n "checking for $ac_word... " >&6; }
19485 if ${ac_cv_path_CHECK_MAKE+:} false; then :
19486   $as_echo_n "(cached) " >&6
19487 else
19488   case $CHECK_MAKE in
19489   [\\/]* | ?:[\\/]*)
19490   ac_cv_path_CHECK_MAKE="$CHECK_MAKE" # Let the user override the test with a path.
19491   ;;
19492   *)
19493   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19494 for as_dir in $PATH
19495 do
19496   IFS=$as_save_IFS
19497   test -z "$as_dir" && as_dir=.
19498     for ac_exec_ext in '' $ac_executable_extensions; do
19499   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19500     ac_cv_path_CHECK_MAKE="$as_dir/$ac_word$ac_exec_ext"
19501     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19502     break 2
19503   fi
19504 done
19505   done
19506 IFS=$as_save_IFS
19507 
19508   ;;
19509 esac
19510 fi
19511 CHECK_MAKE=$ac_cv_path_CHECK_MAKE
19512 if test -n "$CHECK_MAKE"; then
19513   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_MAKE" >&5
19514 $as_echo "$CHECK_MAKE" >&6; }
19515 else
19516   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19517 $as_echo "no" >&6; }
19518 fi
19519 
19520 
19521   test -n "$CHECK_MAKE" && break
19522 done
19523 
19524 
19525   MAKE_CANDIDATE=""$CHECK_MAKE""
19526   DESCRIPTION="make in PATH"
19527 
19528   # On Cygwin, we require a newer version of make than on other platforms
19529   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19530     MAKE_VERSION_EXPR="-e 4\."
19531     MAKE_REQUIRED_VERSION="4.0"
19532    else
19533     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
19534     MAKE_REQUIRED_VERSION="3.81"
19535   fi
19536 
19537   if test "x$MAKE_CANDIDATE" != x; then
19538     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
19539 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
19540     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
19541     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
19542     if test "x$IS_GNU_MAKE" = x; then
19543       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
19544 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
19545     else
19546       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
19547       if test "x$IS_MODERN_MAKE" = x; then
19548         { $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
19549 $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;}
19550       else
19551         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
19552           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19553             MAKE_EXPECTED_ENV='cygwin'
19554           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19555             MAKE_EXPECTED_ENV='msys'
19556           else
19557             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
19558           fi
19559           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
19560           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
19561         else
19562           # Not relevant for non-Windows
19563           IS_MAKE_CORRECT_ENV=true
19564         fi
19565         if test "x$IS_MAKE_CORRECT_ENV" = x; then
19566           { $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
19567 $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;}
19568         else
19569           FOUND_MAKE=$MAKE_CANDIDATE
19570 
19571   # Only process if variable expands to non-empty
19572 
19573   if test "x$FOUND_MAKE" != x; then
19574     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19575 
19576   # First separate the path from the arguments. This will split at the first
19577   # space.
19578   complete="$FOUND_MAKE"
19579   path="${complete%% *}"
19580   tmp="$complete EOL"
19581   arguments="${tmp#* }"
19582 
19583   # Input might be given as Windows format, start by converting to
19584   # unix format.
19585   new_path=`$CYGPATH -u "$path"`
19586 
19587   # Now try to locate executable using which
19588   new_path=`$WHICH "$new_path" 2> /dev/null`
19589   # bat and cmd files are not always considered executable in cygwin causing which
19590   # to not find them
19591   if test "x$new_path" = x \
19592       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19593       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19594     new_path=`$CYGPATH -u "$path"`
19595   fi
19596   if test "x$new_path" = x; then
19597     # Oops. Which didn't find the executable.
19598     # The splitting of arguments from the executable at a space might have been incorrect,
19599     # since paths with space are more likely in Windows. Give it another try with the whole
19600     # argument.
19601     path="$complete"
19602     arguments="EOL"
19603     new_path=`$CYGPATH -u "$path"`
19604     new_path=`$WHICH "$new_path" 2> /dev/null`
19605     # bat and cmd files are not always considered executable in cygwin causing which
19606     # to not find them
19607     if test "x$new_path" = x \
19608         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19609         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19610       new_path=`$CYGPATH -u "$path"`
19611     fi
19612     if test "x$new_path" = x; then
19613       # It's still not found. Now this is an unrecoverable error.
19614       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19615 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19616       has_space=`$ECHO "$complete" | $GREP " "`
19617       if test "x$has_space" != x; then
19618         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
19619 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
19620       fi
19621       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19622     fi
19623   fi
19624 
19625   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
19626   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
19627   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
19628   # "foo.exe" is OK but "foo" is an error.
19629   #
19630   # This test is therefore slightly more accurate than "test -f" to check for file presence.
19631   # It is also a way to make sure we got the proper file name for the real test later on.
19632   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
19633   if test "x$test_shortpath" = x; then
19634     # Short path failed, file does not exist as specified.
19635     # Try adding .exe or .cmd
19636     if test -f "${new_path}.exe"; then
19637       input_to_shortpath="${new_path}.exe"
19638     elif test -f "${new_path}.cmd"; then
19639       input_to_shortpath="${new_path}.cmd"
19640     else
19641       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
19642 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
19643       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
19644 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
19645       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19646     fi
19647   else
19648     input_to_shortpath="$new_path"
19649   fi
19650 
19651   # Call helper function which possibly converts this using DOS-style short mode.
19652   # If so, the updated path is stored in $new_path.
19653   new_path="$input_to_shortpath"
19654 
19655   input_path="$input_to_shortpath"
19656   # Check if we need to convert this using DOS-style short mode. If the path
19657   # contains just simple characters, use it. Otherwise (spaces, weird characters),
19658   # take no chances and rewrite it.
19659   # Note: m4 eats our [], so we need to use [ and ] instead.
19660   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
19661   if test "x$has_forbidden_chars" != x; then
19662     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
19663     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
19664     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
19665     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
19666       # Going to short mode and back again did indeed matter. Since short mode is
19667       # case insensitive, let's make it lowercase to improve readability.
19668       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
19669       # Now convert it back to Unix-style (cygpath)
19670       input_path=`$CYGPATH -u "$shortmode_path"`
19671       new_path="$input_path"
19672     fi
19673   fi
19674 
19675   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
19676   if test "x$test_cygdrive_prefix" = x; then
19677     # As a simple fix, exclude /usr/bin since it's not a real path.
19678     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
19679       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
19680       # a path prefixed by /cygdrive for fixpath to work.
19681       new_path="$CYGWIN_ROOT_PATH$input_path"
19682     fi
19683   fi
19684 
19685   # remove trailing .exe if any
19686   new_path="${new_path/%.exe/}"
19687 
19688     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19689 
19690   # First separate the path from the arguments. This will split at the first
19691   # space.
19692   complete="$FOUND_MAKE"
19693   path="${complete%% *}"
19694   tmp="$complete EOL"
19695   arguments="${tmp#* }"
19696 
19697   # Input might be given as Windows format, start by converting to
19698   # unix format.
19699   new_path="$path"
19700 
19701   windows_path="$new_path"
19702   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19703     unix_path=`$CYGPATH -u "$windows_path"`
19704     new_path="$unix_path"
19705   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19706     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19707     new_path="$unix_path"
19708   fi
19709 
19710 
19711   # Now try to locate executable using which
19712   new_path=`$WHICH "$new_path" 2> /dev/null`
19713 
19714   if test "x$new_path" = x; then
19715     # Oops. Which didn't find the executable.
19716     # The splitting of arguments from the executable at a space might have been incorrect,
19717     # since paths with space are more likely in Windows. Give it another try with the whole
19718     # argument.
19719     path="$complete"
19720     arguments="EOL"
19721     new_path="$path"
19722 
19723   windows_path="$new_path"
19724   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19725     unix_path=`$CYGPATH -u "$windows_path"`
19726     new_path="$unix_path"
19727   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19728     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19729     new_path="$unix_path"
19730   fi
19731 
19732 
19733     new_path=`$WHICH "$new_path" 2> /dev/null`
19734     # bat and cmd files are not always considered executable in MSYS causing which
19735     # to not find them
19736     if test "x$new_path" = x \
19737         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19738         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19739       new_path="$path"
19740 
19741   windows_path="$new_path"
19742   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19743     unix_path=`$CYGPATH -u "$windows_path"`
19744     new_path="$unix_path"
19745   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19746     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19747     new_path="$unix_path"
19748   fi
19749 
19750     fi
19751 
19752     if test "x$new_path" = x; then
19753       # It's still not found. Now this is an unrecoverable error.
19754       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19755 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19756       has_space=`$ECHO "$complete" | $GREP " "`
19757       if test "x$has_space" != x; then
19758         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
19759 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
19760       fi
19761       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19762     fi
19763   fi
19764 
19765   # Now new_path has a complete unix path to the binary
19766   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
19767     # Keep paths in /bin as-is, but remove trailing .exe if any
19768     new_path="${new_path/%.exe/}"
19769     # Do not save /bin paths to all_fixpath_prefixes!
19770   else
19771     # Not in mixed or Windows style, start by that.
19772     new_path=`cmd //c echo $new_path`
19773 
19774   input_path="$new_path"
19775   # Check if we need to convert this using DOS-style short mode. If the path
19776   # contains just simple characters, use it. Otherwise (spaces, weird characters),
19777   # take no chances and rewrite it.
19778   # Note: m4 eats our [], so we need to use [ and ] instead.
19779   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
19780   if test "x$has_forbidden_chars" != x; then
19781     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
19782     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
19783   fi
19784 
19785     # Output is in $new_path
19786 
19787   windows_path="$new_path"
19788   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19789     unix_path=`$CYGPATH -u "$windows_path"`
19790     new_path="$unix_path"
19791   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19792     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19793     new_path="$unix_path"
19794   fi
19795 
19796     # remove trailing .exe if any
19797     new_path="${new_path/%.exe/}"
19798 
19799     # Save the first 10 bytes of this path to the storage, so fixpath can work.
19800     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
19801   fi
19802 
19803     else
19804       # We're on a unix platform. Hooray! :)
19805       # First separate the path from the arguments. This will split at the first
19806       # space.
19807       complete="$FOUND_MAKE"
19808       path="${complete%% *}"
19809       tmp="$complete EOL"
19810       arguments="${tmp#* }"
19811 
19812       # Cannot rely on the command "which" here since it doesn't always work.
19813       is_absolute_path=`$ECHO "$path" | $GREP ^/`
19814       if test -z "$is_absolute_path"; then
19815         # Path to executable is not absolute. Find it.
19816         IFS_save="$IFS"
19817         IFS=:
19818         for p in $PATH; do
19819           if test -f "$p/$path" && test -x "$p/$path"; then
19820             new_path="$p/$path"
19821             break
19822           fi
19823         done
19824         IFS="$IFS_save"
19825       else
19826         # This is an absolute path, we can use it without further modifications.
19827         new_path="$path"
19828       fi
19829 
19830       if test "x$new_path" = x; then
19831         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19832 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19833         has_space=`$ECHO "$complete" | $GREP " "`
19834         if test "x$has_space" != x; then
19835           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
19836 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
19837         fi
19838         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19839       fi
19840     fi
19841 
19842     # Now join together the path and the arguments once again
19843     if test "x$arguments" != xEOL; then
19844       new_complete="$new_path ${arguments% *}"
19845     else
19846       new_complete="$new_path"
19847     fi
19848 
19849     if test "x$complete" != "x$new_complete"; then
19850       FOUND_MAKE="$new_complete"
19851       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
19852 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
19853     fi
19854   fi
19855 
19856         fi
19857       fi
19858     fi
19859   fi
19860 
19861     fi
19862 
19863     if test "x$FOUND_MAKE" = x; then
19864       if test "x$TOOLCHAIN_PATH" != x; then
19865         # We have a toolchain path, check that as well before giving up.
19866         OLD_PATH=$PATH
19867         PATH=$TOOLCHAIN_PATH:$PATH
19868         for ac_prog in gmake
19869 do
19870   # Extract the first word of "$ac_prog", so it can be a program name with args.
19871 set dummy $ac_prog; ac_word=$2
19872 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19873 $as_echo_n "checking for $ac_word... " >&6; }
19874 if ${ac_cv_path_CHECK_TOOLSDIR_GMAKE+:} false; then :
19875   $as_echo_n "(cached) " >&6
19876 else
19877   case $CHECK_TOOLSDIR_GMAKE in
19878   [\\/]* | ?:[\\/]*)
19879   ac_cv_path_CHECK_TOOLSDIR_GMAKE="$CHECK_TOOLSDIR_GMAKE" # Let the user override the test with a path.
19880   ;;
19881   *)
19882   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19883 for as_dir in $PATH
19884 do
19885   IFS=$as_save_IFS
19886   test -z "$as_dir" && as_dir=.
19887     for ac_exec_ext in '' $ac_executable_extensions; do
19888   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19889     ac_cv_path_CHECK_TOOLSDIR_GMAKE="$as_dir/$ac_word$ac_exec_ext"
19890     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19891     break 2
19892   fi
19893 done
19894   done
19895 IFS=$as_save_IFS
19896 
19897   ;;
19898 esac
19899 fi
19900 CHECK_TOOLSDIR_GMAKE=$ac_cv_path_CHECK_TOOLSDIR_GMAKE
19901 if test -n "$CHECK_TOOLSDIR_GMAKE"; then
19902   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_GMAKE" >&5
19903 $as_echo "$CHECK_TOOLSDIR_GMAKE" >&6; }
19904 else
19905   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19906 $as_echo "no" >&6; }
19907 fi
19908 
19909 
19910   test -n "$CHECK_TOOLSDIR_GMAKE" && break
19911 done
19912 
19913 
19914   MAKE_CANDIDATE=""$CHECK_TOOLSDIR_GMAKE""
19915   DESCRIPTION="gmake in tools-dir"
19916 
19917   # On Cygwin, we require a newer version of make than on other platforms
19918   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19919     MAKE_VERSION_EXPR="-e 4\."
19920     MAKE_REQUIRED_VERSION="4.0"
19921    else
19922     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
19923     MAKE_REQUIRED_VERSION="3.81"
19924   fi
19925 
19926   if test "x$MAKE_CANDIDATE" != x; then
19927     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
19928 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
19929     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
19930     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
19931     if test "x$IS_GNU_MAKE" = x; then
19932       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
19933 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
19934     else
19935       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
19936       if test "x$IS_MODERN_MAKE" = x; then
19937         { $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
19938 $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;}
19939       else
19940         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
19941           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19942             MAKE_EXPECTED_ENV='cygwin'
19943           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19944             MAKE_EXPECTED_ENV='msys'
19945           else
19946             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
19947           fi
19948           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
19949           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
19950         else
19951           # Not relevant for non-Windows
19952           IS_MAKE_CORRECT_ENV=true
19953         fi
19954         if test "x$IS_MAKE_CORRECT_ENV" = x; then
19955           { $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
19956 $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;}
19957         else
19958           FOUND_MAKE=$MAKE_CANDIDATE
19959 
19960   # Only process if variable expands to non-empty
19961 
19962   if test "x$FOUND_MAKE" != x; then
19963     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19964 
19965   # First separate the path from the arguments. This will split at the first
19966   # space.
19967   complete="$FOUND_MAKE"
19968   path="${complete%% *}"
19969   tmp="$complete EOL"
19970   arguments="${tmp#* }"
19971 
19972   # Input might be given as Windows format, start by converting to
19973   # unix format.
19974   new_path=`$CYGPATH -u "$path"`
19975 
19976   # Now try to locate executable using which
19977   new_path=`$WHICH "$new_path" 2> /dev/null`
19978   # bat and cmd files are not always considered executable in cygwin causing which
19979   # to not find them
19980   if test "x$new_path" = x \
19981       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19982       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19983     new_path=`$CYGPATH -u "$path"`
19984   fi
19985   if test "x$new_path" = x; then
19986     # Oops. Which didn't find the executable.
19987     # The splitting of arguments from the executable at a space might have been incorrect,
19988     # since paths with space are more likely in Windows. Give it another try with the whole
19989     # argument.
19990     path="$complete"
19991     arguments="EOL"
19992     new_path=`$CYGPATH -u "$path"`
19993     new_path=`$WHICH "$new_path" 2> /dev/null`
19994     # bat and cmd files are not always considered executable in cygwin causing which
19995     # to not find them
19996     if test "x$new_path" = x \
19997         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19998         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19999       new_path=`$CYGPATH -u "$path"`
20000     fi
20001     if test "x$new_path" = x; then
20002       # It's still not found. Now this is an unrecoverable error.
20003       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
20004 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
20005       has_space=`$ECHO "$complete" | $GREP " "`
20006       if test "x$has_space" != x; then
20007         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
20008 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
20009       fi
20010       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
20011     fi
20012   fi
20013 
20014   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
20015   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
20016   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
20017   # "foo.exe" is OK but "foo" is an error.
20018   #
20019   # This test is therefore slightly more accurate than "test -f" to check for file presence.
20020   # It is also a way to make sure we got the proper file name for the real test later on.
20021   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
20022   if test "x$test_shortpath" = x; then
20023     # Short path failed, file does not exist as specified.
20024     # Try adding .exe or .cmd
20025     if test -f "${new_path}.exe"; then
20026       input_to_shortpath="${new_path}.exe"
20027     elif test -f "${new_path}.cmd"; then
20028       input_to_shortpath="${new_path}.cmd"
20029     else
20030       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
20031 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
20032       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
20033 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
20034       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
20035     fi
20036   else
20037     input_to_shortpath="$new_path"
20038   fi
20039 
20040   # Call helper function which possibly converts this using DOS-style short mode.
20041   # If so, the updated path is stored in $new_path.
20042   new_path="$input_to_shortpath"
20043 
20044   input_path="$input_to_shortpath"
20045   # Check if we need to convert this using DOS-style short mode. If the path
20046   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20047   # take no chances and rewrite it.
20048   # Note: m4 eats our [], so we need to use [ and ] instead.
20049   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20050   if test "x$has_forbidden_chars" != x; then
20051     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20052     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20053     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20054     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20055       # Going to short mode and back again did indeed matter. Since short mode is
20056       # case insensitive, let's make it lowercase to improve readability.
20057       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20058       # Now convert it back to Unix-style (cygpath)
20059       input_path=`$CYGPATH -u "$shortmode_path"`
20060       new_path="$input_path"
20061     fi
20062   fi
20063 
20064   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20065   if test "x$test_cygdrive_prefix" = x; then
20066     # As a simple fix, exclude /usr/bin since it's not a real path.
20067     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
20068       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20069       # a path prefixed by /cygdrive for fixpath to work.
20070       new_path="$CYGWIN_ROOT_PATH$input_path"
20071     fi
20072   fi
20073 
20074   # remove trailing .exe if any
20075   new_path="${new_path/%.exe/}"
20076 
20077     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20078 
20079   # First separate the path from the arguments. This will split at the first
20080   # space.
20081   complete="$FOUND_MAKE"
20082   path="${complete%% *}"
20083   tmp="$complete EOL"
20084   arguments="${tmp#* }"
20085 
20086   # Input might be given as Windows format, start by converting to
20087   # unix format.
20088   new_path="$path"
20089 
20090   windows_path="$new_path"
20091   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20092     unix_path=`$CYGPATH -u "$windows_path"`
20093     new_path="$unix_path"
20094   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20095     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20096     new_path="$unix_path"
20097   fi
20098 
20099 
20100   # Now try to locate executable using which
20101   new_path=`$WHICH "$new_path" 2> /dev/null`
20102 
20103   if test "x$new_path" = x; then
20104     # Oops. Which didn't find the executable.
20105     # The splitting of arguments from the executable at a space might have been incorrect,
20106     # since paths with space are more likely in Windows. Give it another try with the whole
20107     # argument.
20108     path="$complete"
20109     arguments="EOL"
20110     new_path="$path"
20111 
20112   windows_path="$new_path"
20113   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20114     unix_path=`$CYGPATH -u "$windows_path"`
20115     new_path="$unix_path"
20116   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20117     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20118     new_path="$unix_path"
20119   fi
20120 
20121 
20122     new_path=`$WHICH "$new_path" 2> /dev/null`
20123     # bat and cmd files are not always considered executable in MSYS causing which
20124     # to not find them
20125     if test "x$new_path" = x \
20126         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
20127         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
20128       new_path="$path"
20129 
20130   windows_path="$new_path"
20131   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20132     unix_path=`$CYGPATH -u "$windows_path"`
20133     new_path="$unix_path"
20134   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20135     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20136     new_path="$unix_path"
20137   fi
20138 
20139     fi
20140 
20141     if test "x$new_path" = x; then
20142       # It's still not found. Now this is an unrecoverable error.
20143       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
20144 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
20145       has_space=`$ECHO "$complete" | $GREP " "`
20146       if test "x$has_space" != x; then
20147         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
20148 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
20149       fi
20150       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
20151     fi
20152   fi
20153 
20154   # Now new_path has a complete unix path to the binary
20155   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
20156     # Keep paths in /bin as-is, but remove trailing .exe if any
20157     new_path="${new_path/%.exe/}"
20158     # Do not save /bin paths to all_fixpath_prefixes!
20159   else
20160     # Not in mixed or Windows style, start by that.
20161     new_path=`cmd //c echo $new_path`
20162 
20163   input_path="$new_path"
20164   # Check if we need to convert this using DOS-style short mode. If the path
20165   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20166   # take no chances and rewrite it.
20167   # Note: m4 eats our [], so we need to use [ and ] instead.
20168   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20169   if test "x$has_forbidden_chars" != x; then
20170     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20171     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20172   fi
20173 
20174     # Output is in $new_path
20175 
20176   windows_path="$new_path"
20177   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20178     unix_path=`$CYGPATH -u "$windows_path"`
20179     new_path="$unix_path"
20180   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20181     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20182     new_path="$unix_path"
20183   fi
20184 
20185     # remove trailing .exe if any
20186     new_path="${new_path/%.exe/}"
20187 
20188     # Save the first 10 bytes of this path to the storage, so fixpath can work.
20189     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20190   fi
20191 
20192     else
20193       # We're on a unix platform. Hooray! :)
20194       # First separate the path from the arguments. This will split at the first
20195       # space.
20196       complete="$FOUND_MAKE"
20197       path="${complete%% *}"
20198       tmp="$complete EOL"
20199       arguments="${tmp#* }"
20200 
20201       # Cannot rely on the command "which" here since it doesn't always work.
20202       is_absolute_path=`$ECHO "$path" | $GREP ^/`
20203       if test -z "$is_absolute_path"; then
20204         # Path to executable is not absolute. Find it.
20205         IFS_save="$IFS"
20206         IFS=:
20207         for p in $PATH; do
20208           if test -f "$p/$path" && test -x "$p/$path"; then
20209             new_path="$p/$path"
20210             break
20211           fi
20212         done
20213         IFS="$IFS_save"
20214       else
20215         # This is an absolute path, we can use it without further modifications.
20216         new_path="$path"
20217       fi
20218 
20219       if test "x$new_path" = x; then
20220         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
20221 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
20222         has_space=`$ECHO "$complete" | $GREP " "`
20223         if test "x$has_space" != x; then
20224           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
20225 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
20226         fi
20227         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
20228       fi
20229     fi
20230 
20231     # Now join together the path and the arguments once again
20232     if test "x$arguments" != xEOL; then
20233       new_complete="$new_path ${arguments% *}"
20234     else
20235       new_complete="$new_path"
20236     fi
20237 
20238     if test "x$complete" != "x$new_complete"; then
20239       FOUND_MAKE="$new_complete"
20240       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
20241 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
20242     fi
20243   fi
20244 
20245         fi
20246       fi
20247     fi
20248   fi
20249 
20250         if test "x$FOUND_MAKE" = x; then
20251           for ac_prog in make
20252 do
20253   # Extract the first word of "$ac_prog", so it can be a program name with args.
20254 set dummy $ac_prog; ac_word=$2
20255 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
20256 $as_echo_n "checking for $ac_word... " >&6; }
20257 if ${ac_cv_path_CHECK_TOOLSDIR_MAKE+:} false; then :
20258   $as_echo_n "(cached) " >&6
20259 else
20260   case $CHECK_TOOLSDIR_MAKE in
20261   [\\/]* | ?:[\\/]*)
20262   ac_cv_path_CHECK_TOOLSDIR_MAKE="$CHECK_TOOLSDIR_MAKE" # Let the user override the test with a path.
20263   ;;
20264   *)
20265   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
20266 for as_dir in $PATH
20267 do
20268   IFS=$as_save_IFS
20269   test -z "$as_dir" && as_dir=.
20270     for ac_exec_ext in '' $ac_executable_extensions; do
20271   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
20272     ac_cv_path_CHECK_TOOLSDIR_MAKE="$as_dir/$ac_word$ac_exec_ext"
20273     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
20274     break 2
20275   fi
20276 done
20277   done
20278 IFS=$as_save_IFS
20279 
20280   ;;
20281 esac
20282 fi
20283 CHECK_TOOLSDIR_MAKE=$ac_cv_path_CHECK_TOOLSDIR_MAKE
20284 if test -n "$CHECK_TOOLSDIR_MAKE"; then
20285   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_MAKE" >&5
20286 $as_echo "$CHECK_TOOLSDIR_MAKE" >&6; }
20287 else
20288   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20289 $as_echo "no" >&6; }
20290 fi
20291 
20292 
20293   test -n "$CHECK_TOOLSDIR_MAKE" && break
20294 done
20295 
20296 
20297   MAKE_CANDIDATE=""$CHECK_TOOLSDIR_MAKE""
20298   DESCRIPTION="make in tools-dir"
20299 
20300   # On Cygwin, we require a newer version of make than on other platforms
20301   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20302     MAKE_VERSION_EXPR="-e 4\."
20303     MAKE_REQUIRED_VERSION="4.0"
20304    else
20305     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
20306     MAKE_REQUIRED_VERSION="3.81"
20307   fi
20308 
20309   if test "x$MAKE_CANDIDATE" != x; then
20310     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
20311 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
20312     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
20313     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
20314     if test "x$IS_GNU_MAKE" = x; then
20315       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
20316 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
20317     else
20318       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
20319       if test "x$IS_MODERN_MAKE" = x; then
20320         { $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
20321 $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;}
20322       else
20323         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
20324           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20325             MAKE_EXPECTED_ENV='cygwin'
20326           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20327             MAKE_EXPECTED_ENV='msys'
20328           else
20329             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
20330           fi
20331           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
20332           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
20333         else
20334           # Not relevant for non-Windows
20335           IS_MAKE_CORRECT_ENV=true
20336         fi
20337         if test "x$IS_MAKE_CORRECT_ENV" = x; then
20338           { $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
20339 $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;}
20340         else
20341           FOUND_MAKE=$MAKE_CANDIDATE
20342 
20343   # Only process if variable expands to non-empty
20344 
20345   if test "x$FOUND_MAKE" != x; then
20346     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20347 
20348   # First separate the path from the arguments. This will split at the first
20349   # space.
20350   complete="$FOUND_MAKE"
20351   path="${complete%% *}"
20352   tmp="$complete EOL"
20353   arguments="${tmp#* }"
20354 
20355   # Input might be given as Windows format, start by converting to
20356   # unix format.
20357   new_path=`$CYGPATH -u "$path"`
20358 
20359   # Now try to locate executable using which
20360   new_path=`$WHICH "$new_path" 2> /dev/null`
20361   # bat and cmd files are not always considered executable in cygwin causing which
20362   # to not find them
20363   if test "x$new_path" = x \
20364       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
20365       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
20366     new_path=`$CYGPATH -u "$path"`
20367   fi
20368   if test "x$new_path" = x; then
20369     # Oops. Which didn't find the executable.
20370     # The splitting of arguments from the executable at a space might have been incorrect,
20371     # since paths with space are more likely in Windows. Give it another try with the whole
20372     # argument.
20373     path="$complete"
20374     arguments="EOL"
20375     new_path=`$CYGPATH -u "$path"`
20376     new_path=`$WHICH "$new_path" 2> /dev/null`
20377     # bat and cmd files are not always considered executable in cygwin causing which
20378     # to not find them
20379     if test "x$new_path" = x \
20380         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
20381         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
20382       new_path=`$CYGPATH -u "$path"`
20383     fi
20384     if test "x$new_path" = x; then
20385       # It's still not found. Now this is an unrecoverable error.
20386       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
20387 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
20388       has_space=`$ECHO "$complete" | $GREP " "`
20389       if test "x$has_space" != x; then
20390         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
20391 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
20392       fi
20393       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
20394     fi
20395   fi
20396 
20397   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
20398   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
20399   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
20400   # "foo.exe" is OK but "foo" is an error.
20401   #
20402   # This test is therefore slightly more accurate than "test -f" to check for file presence.
20403   # It is also a way to make sure we got the proper file name for the real test later on.
20404   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
20405   if test "x$test_shortpath" = x; then
20406     # Short path failed, file does not exist as specified.
20407     # Try adding .exe or .cmd
20408     if test -f "${new_path}.exe"; then
20409       input_to_shortpath="${new_path}.exe"
20410     elif test -f "${new_path}.cmd"; then
20411       input_to_shortpath="${new_path}.cmd"
20412     else
20413       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
20414 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
20415       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
20416 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
20417       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
20418     fi
20419   else
20420     input_to_shortpath="$new_path"
20421   fi
20422 
20423   # Call helper function which possibly converts this using DOS-style short mode.
20424   # If so, the updated path is stored in $new_path.
20425   new_path="$input_to_shortpath"
20426 
20427   input_path="$input_to_shortpath"
20428   # Check if we need to convert this using DOS-style short mode. If the path
20429   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20430   # take no chances and rewrite it.
20431   # Note: m4 eats our [], so we need to use [ and ] instead.
20432   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20433   if test "x$has_forbidden_chars" != x; then
20434     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20435     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20436     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20437     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20438       # Going to short mode and back again did indeed matter. Since short mode is
20439       # case insensitive, let's make it lowercase to improve readability.
20440       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20441       # Now convert it back to Unix-style (cygpath)
20442       input_path=`$CYGPATH -u "$shortmode_path"`
20443       new_path="$input_path"
20444     fi
20445   fi
20446 
20447   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20448   if test "x$test_cygdrive_prefix" = x; then
20449     # As a simple fix, exclude /usr/bin since it's not a real path.
20450     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
20451       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20452       # a path prefixed by /cygdrive for fixpath to work.
20453       new_path="$CYGWIN_ROOT_PATH$input_path"
20454     fi
20455   fi
20456 
20457   # remove trailing .exe if any
20458   new_path="${new_path/%.exe/}"
20459 
20460     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20461 
20462   # First separate the path from the arguments. This will split at the first
20463   # space.
20464   complete="$FOUND_MAKE"
20465   path="${complete%% *}"
20466   tmp="$complete EOL"
20467   arguments="${tmp#* }"
20468 
20469   # Input might be given as Windows format, start by converting to
20470   # unix format.
20471   new_path="$path"
20472 
20473   windows_path="$new_path"
20474   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20475     unix_path=`$CYGPATH -u "$windows_path"`
20476     new_path="$unix_path"
20477   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20478     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20479     new_path="$unix_path"
20480   fi
20481 
20482 
20483   # Now try to locate executable using which
20484   new_path=`$WHICH "$new_path" 2> /dev/null`
20485 
20486   if test "x$new_path" = x; then
20487     # Oops. Which didn't find the executable.
20488     # The splitting of arguments from the executable at a space might have been incorrect,
20489     # since paths with space are more likely in Windows. Give it another try with the whole
20490     # argument.
20491     path="$complete"
20492     arguments="EOL"
20493     new_path="$path"
20494 
20495   windows_path="$new_path"
20496   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20497     unix_path=`$CYGPATH -u "$windows_path"`
20498     new_path="$unix_path"
20499   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20500     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20501     new_path="$unix_path"
20502   fi
20503 
20504 
20505     new_path=`$WHICH "$new_path" 2> /dev/null`
20506     # bat and cmd files are not always considered executable in MSYS causing which
20507     # to not find them
20508     if test "x$new_path" = x \
20509         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
20510         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
20511       new_path="$path"
20512 
20513   windows_path="$new_path"
20514   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20515     unix_path=`$CYGPATH -u "$windows_path"`
20516     new_path="$unix_path"
20517   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20518     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20519     new_path="$unix_path"
20520   fi
20521 
20522     fi
20523 
20524     if test "x$new_path" = x; then
20525       # It's still not found. Now this is an unrecoverable error.
20526       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
20527 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
20528       has_space=`$ECHO "$complete" | $GREP " "`
20529       if test "x$has_space" != x; then
20530         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
20531 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
20532       fi
20533       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
20534     fi
20535   fi
20536 
20537   # Now new_path has a complete unix path to the binary
20538   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
20539     # Keep paths in /bin as-is, but remove trailing .exe if any
20540     new_path="${new_path/%.exe/}"
20541     # Do not save /bin paths to all_fixpath_prefixes!
20542   else
20543     # Not in mixed or Windows style, start by that.
20544     new_path=`cmd //c echo $new_path`
20545 
20546   input_path="$new_path"
20547   # Check if we need to convert this using DOS-style short mode. If the path
20548   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20549   # take no chances and rewrite it.
20550   # Note: m4 eats our [], so we need to use [ and ] instead.
20551   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20552   if test "x$has_forbidden_chars" != x; then
20553     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20554     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20555   fi
20556 
20557     # Output is in $new_path
20558 
20559   windows_path="$new_path"
20560   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20561     unix_path=`$CYGPATH -u "$windows_path"`
20562     new_path="$unix_path"
20563   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20564     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20565     new_path="$unix_path"
20566   fi
20567 
20568     # remove trailing .exe if any
20569     new_path="${new_path/%.exe/}"
20570 
20571     # Save the first 10 bytes of this path to the storage, so fixpath can work.
20572     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20573   fi
20574 
20575     else
20576       # We're on a unix platform. Hooray! :)
20577       # First separate the path from the arguments. This will split at the first
20578       # space.
20579       complete="$FOUND_MAKE"
20580       path="${complete%% *}"
20581       tmp="$complete EOL"
20582       arguments="${tmp#* }"
20583 
20584       # Cannot rely on the command "which" here since it doesn't always work.
20585       is_absolute_path=`$ECHO "$path" | $GREP ^/`
20586       if test -z "$is_absolute_path"; then
20587         # Path to executable is not absolute. Find it.
20588         IFS_save="$IFS"
20589         IFS=:
20590         for p in $PATH; do
20591           if test -f "$p/$path" && test -x "$p/$path"; then
20592             new_path="$p/$path"
20593             break
20594           fi
20595         done
20596         IFS="$IFS_save"
20597       else
20598         # This is an absolute path, we can use it without further modifications.
20599         new_path="$path"
20600       fi
20601 
20602       if test "x$new_path" = x; then
20603         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
20604 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
20605         has_space=`$ECHO "$complete" | $GREP " "`
20606         if test "x$has_space" != x; then
20607           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
20608 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
20609         fi
20610         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
20611       fi
20612     fi
20613 
20614     # Now join together the path and the arguments once again
20615     if test "x$arguments" != xEOL; then
20616       new_complete="$new_path ${arguments% *}"
20617     else
20618       new_complete="$new_path"
20619     fi
20620 
20621     if test "x$complete" != "x$new_complete"; then
20622       FOUND_MAKE="$new_complete"
20623       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
20624 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
20625     fi
20626   fi
20627 
20628         fi
20629       fi
20630     fi
20631   fi
20632 
20633         fi
20634         PATH=$OLD_PATH
20635       fi
20636     fi
20637 
20638     if test "x$FOUND_MAKE" = x; then
20639       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
20640     fi
20641 
20642     else
20643       # If it succeeded, then it was overridden by the user. We will use it
20644       # for the tool.
20645 
20646       # First remove it from the list of overridden variables, so we can test
20647       # for unknown variables in the end.
20648       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
20649 
20650       # Check if we try to supply an empty value
20651       if test "x$MAKE" = x; then
20652         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool MAKE= (no value)" >&5
20653 $as_echo "$as_me: Setting user supplied tool MAKE= (no value)" >&6;}
20654         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MAKE" >&5
20655 $as_echo_n "checking for MAKE... " >&6; }
20656         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
20657 $as_echo "disabled" >&6; }
20658       else
20659         # Check if the provided tool contains a complete path.
20660         tool_specified="$MAKE"
20661         tool_basename="${tool_specified##*/}"
20662         if test "x$tool_basename" = "x$tool_specified"; then
20663           # A command without a complete path is provided, search $PATH.
20664           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MAKE=$tool_basename" >&5
20665 $as_echo "$as_me: Will search for user supplied tool MAKE=$tool_basename" >&6;}
20666           # Extract the first word of "$tool_basename", so it can be a program name with args.
20667 set dummy $tool_basename; ac_word=$2
20668 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
20669 $as_echo_n "checking for $ac_word... " >&6; }
20670 if ${ac_cv_path_MAKE+:} false; then :
20671   $as_echo_n "(cached) " >&6
20672 else
20673   case $MAKE in
20674   [\\/]* | ?:[\\/]*)
20675   ac_cv_path_MAKE="$MAKE" # Let the user override the test with a path.
20676   ;;
20677   *)
20678   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
20679 for as_dir in $PATH
20680 do
20681   IFS=$as_save_IFS
20682   test -z "$as_dir" && as_dir=.
20683     for ac_exec_ext in '' $ac_executable_extensions; do
20684   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
20685     ac_cv_path_MAKE="$as_dir/$ac_word$ac_exec_ext"
20686     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
20687     break 2
20688   fi
20689 done
20690   done
20691 IFS=$as_save_IFS
20692 
20693   ;;
20694 esac
20695 fi
20696 MAKE=$ac_cv_path_MAKE
20697 if test -n "$MAKE"; then
20698   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MAKE" >&5
20699 $as_echo "$MAKE" >&6; }
20700 else
20701   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20702 $as_echo "no" >&6; }
20703 fi
20704 
20705 
20706           if test "x$MAKE" = x; then
20707             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
20708           fi
20709         else
20710           # Otherwise we believe it is a complete path. Use it as it is.
20711           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MAKE=$tool_specified" >&5
20712 $as_echo "$as_me: Will use user supplied tool MAKE=$tool_specified" >&6;}
20713           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MAKE" >&5
20714 $as_echo_n "checking for MAKE... " >&6; }
20715           if test ! -x "$tool_specified"; then
20716             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
20717 $as_echo "not found" >&6; }
20718             as_fn_error $? "User supplied tool MAKE=$tool_specified does not exist or is not executable" "$LINENO" 5
20719           fi
20720           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
20721 $as_echo "$tool_specified" >&6; }
20722         fi
20723       fi
20724     fi
20725 
20726     # If MAKE was set by user, verify the version
20727 
20728   MAKE_CANDIDATE=""$MAKE""
20729   DESCRIPTION="user supplied MAKE=$MAKE"
20730 
20731   # On Cygwin, we require a newer version of make than on other platforms
20732   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20733     MAKE_VERSION_EXPR="-e 4\."
20734     MAKE_REQUIRED_VERSION="4.0"
20735    else
20736     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
20737     MAKE_REQUIRED_VERSION="3.81"
20738   fi
20739 
20740   if test "x$MAKE_CANDIDATE" != x; then
20741     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
20742 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
20743     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
20744     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
20745     if test "x$IS_GNU_MAKE" = x; then
20746       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
20747 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
20748     else
20749       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
20750       if test "x$IS_MODERN_MAKE" = x; then
20751         { $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
20752 $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;}
20753       else
20754         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
20755           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20756             MAKE_EXPECTED_ENV='cygwin'
20757           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20758             MAKE_EXPECTED_ENV='msys'
20759           else
20760             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
20761           fi
20762           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
20763           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
20764         else
20765           # Not relevant for non-Windows
20766           IS_MAKE_CORRECT_ENV=true
20767         fi
20768         if test "x$IS_MAKE_CORRECT_ENV" = x; then
20769           { $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
20770 $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;}
20771         else
20772           FOUND_MAKE=$MAKE_CANDIDATE
20773 
20774   # Only process if variable expands to non-empty
20775 
20776   if test "x$FOUND_MAKE" != x; then
20777     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20778 
20779   # First separate the path from the arguments. This will split at the first
20780   # space.
20781   complete="$FOUND_MAKE"
20782   path="${complete%% *}"
20783   tmp="$complete EOL"
20784   arguments="${tmp#* }"
20785 
20786   # Input might be given as Windows format, start by converting to
20787   # unix format.
20788   new_path=`$CYGPATH -u "$path"`
20789 
20790   # Now try to locate executable using which
20791   new_path=`$WHICH "$new_path" 2> /dev/null`
20792   # bat and cmd files are not always considered executable in cygwin causing which
20793   # to not find them
20794   if test "x$new_path" = x \
20795       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
20796       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
20797     new_path=`$CYGPATH -u "$path"`
20798   fi
20799   if test "x$new_path" = x; then
20800     # Oops. Which didn't find the executable.
20801     # The splitting of arguments from the executable at a space might have been incorrect,
20802     # since paths with space are more likely in Windows. Give it another try with the whole
20803     # argument.
20804     path="$complete"
20805     arguments="EOL"
20806     new_path=`$CYGPATH -u "$path"`
20807     new_path=`$WHICH "$new_path" 2> /dev/null`
20808     # bat and cmd files are not always considered executable in cygwin causing which
20809     # to not find them
20810     if test "x$new_path" = x \
20811         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
20812         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
20813       new_path=`$CYGPATH -u "$path"`
20814     fi
20815     if test "x$new_path" = x; then
20816       # It's still not found. Now this is an unrecoverable error.
20817       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
20818 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
20819       has_space=`$ECHO "$complete" | $GREP " "`
20820       if test "x$has_space" != x; then
20821         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
20822 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
20823       fi
20824       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
20825     fi
20826   fi
20827 
20828   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
20829   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
20830   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
20831   # "foo.exe" is OK but "foo" is an error.
20832   #
20833   # This test is therefore slightly more accurate than "test -f" to check for file presence.
20834   # It is also a way to make sure we got the proper file name for the real test later on.
20835   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
20836   if test "x$test_shortpath" = x; then
20837     # Short path failed, file does not exist as specified.
20838     # Try adding .exe or .cmd
20839     if test -f "${new_path}.exe"; then
20840       input_to_shortpath="${new_path}.exe"
20841     elif test -f "${new_path}.cmd"; then
20842       input_to_shortpath="${new_path}.cmd"
20843     else
20844       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
20845 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
20846       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
20847 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
20848       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
20849     fi
20850   else
20851     input_to_shortpath="$new_path"
20852   fi
20853 
20854   # Call helper function which possibly converts this using DOS-style short mode.
20855   # If so, the updated path is stored in $new_path.
20856   new_path="$input_to_shortpath"
20857 
20858   input_path="$input_to_shortpath"
20859   # Check if we need to convert this using DOS-style short mode. If the path
20860   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20861   # take no chances and rewrite it.
20862   # Note: m4 eats our [], so we need to use [ and ] instead.
20863   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20864   if test "x$has_forbidden_chars" != x; then
20865     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20866     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20867     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20868     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20869       # Going to short mode and back again did indeed matter. Since short mode is
20870       # case insensitive, let's make it lowercase to improve readability.
20871       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20872       # Now convert it back to Unix-style (cygpath)
20873       input_path=`$CYGPATH -u "$shortmode_path"`
20874       new_path="$input_path"
20875     fi
20876   fi
20877 
20878   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20879   if test "x$test_cygdrive_prefix" = x; then
20880     # As a simple fix, exclude /usr/bin since it's not a real path.
20881     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
20882       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20883       # a path prefixed by /cygdrive for fixpath to work.
20884       new_path="$CYGWIN_ROOT_PATH$input_path"
20885     fi
20886   fi
20887 
20888   # remove trailing .exe if any
20889   new_path="${new_path/%.exe/}"
20890 
20891     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20892 
20893   # First separate the path from the arguments. This will split at the first
20894   # space.
20895   complete="$FOUND_MAKE"
20896   path="${complete%% *}"
20897   tmp="$complete EOL"
20898   arguments="${tmp#* }"
20899 
20900   # Input might be given as Windows format, start by converting to
20901   # unix format.
20902   new_path="$path"
20903 
20904   windows_path="$new_path"
20905   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20906     unix_path=`$CYGPATH -u "$windows_path"`
20907     new_path="$unix_path"
20908   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20909     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20910     new_path="$unix_path"
20911   fi
20912 
20913 
20914   # Now try to locate executable using which
20915   new_path=`$WHICH "$new_path" 2> /dev/null`
20916 
20917   if test "x$new_path" = x; then
20918     # Oops. Which didn't find the executable.
20919     # The splitting of arguments from the executable at a space might have been incorrect,
20920     # since paths with space are more likely in Windows. Give it another try with the whole
20921     # argument.
20922     path="$complete"
20923     arguments="EOL"
20924     new_path="$path"
20925 
20926   windows_path="$new_path"
20927   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20928     unix_path=`$CYGPATH -u "$windows_path"`
20929     new_path="$unix_path"
20930   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20931     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20932     new_path="$unix_path"
20933   fi
20934 
20935 
20936     new_path=`$WHICH "$new_path" 2> /dev/null`
20937     # bat and cmd files are not always considered executable in MSYS causing which
20938     # to not find them
20939     if test "x$new_path" = x \
20940         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
20941         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
20942       new_path="$path"
20943 
20944   windows_path="$new_path"
20945   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20946     unix_path=`$CYGPATH -u "$windows_path"`
20947     new_path="$unix_path"
20948   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20949     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20950     new_path="$unix_path"
20951   fi
20952 
20953     fi
20954 
20955     if test "x$new_path" = x; then
20956       # It's still not found. Now this is an unrecoverable error.
20957       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
20958 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
20959       has_space=`$ECHO "$complete" | $GREP " "`
20960       if test "x$has_space" != x; then
20961         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
20962 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
20963       fi
20964       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
20965     fi
20966   fi
20967 
20968   # Now new_path has a complete unix path to the binary
20969   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
20970     # Keep paths in /bin as-is, but remove trailing .exe if any
20971     new_path="${new_path/%.exe/}"
20972     # Do not save /bin paths to all_fixpath_prefixes!
20973   else
20974     # Not in mixed or Windows style, start by that.
20975     new_path=`cmd //c echo $new_path`
20976 
20977   input_path="$new_path"
20978   # Check if we need to convert this using DOS-style short mode. If the path
20979   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20980   # take no chances and rewrite it.
20981   # Note: m4 eats our [], so we need to use [ and ] instead.
20982   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20983   if test "x$has_forbidden_chars" != x; then
20984     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20985     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20986   fi
20987 
20988     # Output is in $new_path
20989 
20990   windows_path="$new_path"
20991   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20992     unix_path=`$CYGPATH -u "$windows_path"`
20993     new_path="$unix_path"
20994   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20995     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20996     new_path="$unix_path"
20997   fi
20998 
20999     # remove trailing .exe if any
21000     new_path="${new_path/%.exe/}"
21001 
21002     # Save the first 10 bytes of this path to the storage, so fixpath can work.
21003     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21004   fi
21005 
21006     else
21007       # We're on a unix platform. Hooray! :)
21008       # First separate the path from the arguments. This will split at the first
21009       # space.
21010       complete="$FOUND_MAKE"
21011       path="${complete%% *}"
21012       tmp="$complete EOL"
21013       arguments="${tmp#* }"
21014 
21015       # Cannot rely on the command "which" here since it doesn't always work.
21016       is_absolute_path=`$ECHO "$path" | $GREP ^/`
21017       if test -z "$is_absolute_path"; then
21018         # Path to executable is not absolute. Find it.
21019         IFS_save="$IFS"
21020         IFS=:
21021         for p in $PATH; do
21022           if test -f "$p/$path" && test -x "$p/$path"; then
21023             new_path="$p/$path"
21024             break
21025           fi
21026         done
21027         IFS="$IFS_save"
21028       else
21029         # This is an absolute path, we can use it without further modifications.
21030         new_path="$path"
21031       fi
21032 
21033       if test "x$new_path" = x; then
21034         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
21035 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
21036         has_space=`$ECHO "$complete" | $GREP " "`
21037         if test "x$has_space" != x; then
21038           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
21039 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
21040         fi
21041         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
21042       fi
21043     fi
21044 
21045     # Now join together the path and the arguments once again
21046     if test "x$arguments" != xEOL; then
21047       new_complete="$new_path ${arguments% *}"
21048     else
21049       new_complete="$new_path"
21050     fi
21051 
21052     if test "x$complete" != "x$new_complete"; then
21053       FOUND_MAKE="$new_complete"
21054       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
21055 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
21056     fi
21057   fi
21058 
21059         fi
21060       fi
21061     fi
21062   fi
21063 
21064     if test "x$FOUND_MAKE" = x; then
21065       as_fn_error $? "The specified make (by MAKE=$MAKE) is not GNU make $MAKE_REQUIRED_VERSION or newer." "$LINENO" 5
21066     fi
21067 
21068   fi
21069 
21070 
21071   MAKE=$FOUND_MAKE
21072 
21073   { $as_echo "$as_me:${as_lineno-$LINENO}: Using GNU make at $FOUND_MAKE (version: $MAKE_VERSION_STRING)" >&5
21074 $as_echo "$as_me: Using GNU make at $FOUND_MAKE (version: $MAKE_VERSION_STRING)" >&6;}
21075 
21076 
21077   # Check if make supports the output sync option and if so, setup using it.
21078   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if make --output-sync is supported" >&5
21079 $as_echo_n "checking if make --output-sync is supported... " >&6; }
21080   if $MAKE --version -O > /dev/null 2>&1; then
21081     OUTPUT_SYNC_SUPPORTED=true
21082     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
21083 $as_echo "yes" >&6; }
21084     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for output-sync value" >&5
21085 $as_echo_n "checking for output-sync value... " >&6; }
21086 
21087 # Check whether --with-output-sync was given.
21088 if test "${with_output_sync+set}" = set; then :
21089   withval=$with_output_sync; OUTPUT_SYNC=$with_output_sync
21090 fi
21091 
21092     if test "x$OUTPUT_SYNC" = "x"; then
21093       OUTPUT_SYNC=none
21094     fi
21095     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OUTPUT_SYNC" >&5
21096 $as_echo "$OUTPUT_SYNC" >&6; }
21097     if ! $MAKE --version -O$OUTPUT_SYNC > /dev/null 2>&1; then
21098       as_fn_error $? "Make did not the support the value $OUTPUT_SYNC as output sync type." "$LINENO" 5
21099     fi
21100   else
21101     OUTPUT_SYNC_SUPPORTED=false
21102     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21103 $as_echo "no" >&6; }
21104   fi
21105 
21106 
21107 
21108 
21109 
21110 
21111   # Test if find supports -delete
21112   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if find supports -delete" >&5
21113 $as_echo_n "checking if find supports -delete... " >&6; }
21114   FIND_DELETE="-delete"
21115 
21116   DELETEDIR=`$MKTEMP -d tmp.XXXXXXXXXX` || (echo Could not create temporary directory!; exit $?)
21117 
21118   echo Hejsan > $DELETEDIR/TestIfFindSupportsDelete
21119 
21120   TEST_DELETE=`$FIND "$DELETEDIR" -name TestIfFindSupportsDelete $FIND_DELETE 2>&1`
21121   if test -f $DELETEDIR/TestIfFindSupportsDelete; then
21122     # No, it does not.
21123     $RM $DELETEDIR/TestIfFindSupportsDelete
21124     if test "x$OPENJDK_TARGET_OS" = "xaix"; then
21125       # AIX 'find' is buggy if called with '-exec {} \+' and an empty file list
21126       FIND_DELETE="-print | $XARGS $RM"
21127     else
21128       FIND_DELETE="-exec $RM \{\} \+"
21129     fi
21130     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21131 $as_echo "no" >&6; }
21132   else
21133     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
21134 $as_echo "yes" >&6; }
21135   fi
21136   $RMDIR $DELETEDIR
21137 
21138 
21139 
21140   # Test which kind of tar was found
21141   if test "x$($TAR --version | $GREP "GNU tar")" != "x"; then
21142     TAR_TYPE="gnu"
21143   elif test "x$($TAR -v | $GREP "bsdtar")" != "x"; then
21144     TAR_TYPE="bsd"
21145   elif test "x$OPENJDK_BUILD_OS" = "xsolaris"; then
21146     TAR_TYPE="solaris"
21147   fi
21148   { $as_echo "$as_me:${as_lineno-$LINENO}: checking what type of tar was found" >&5
21149 $as_echo_n "checking what type of tar was found... " >&6; }
21150   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR_TYPE" >&5
21151 $as_echo "$TAR_TYPE" >&6; }
21152 
21153   TAR_CREATE_FILE_PARAM=""
21154 
21155   if test "x$TAR_TYPE" = "xgnu"; then
21156     TAR_INCLUDE_PARAM="T"
21157     TAR_SUPPORTS_TRANSFORM="true"
21158     if test "x$OPENJDK_TARGET_OS" = "xsolaris"; then
21159       # When using gnu tar for Solaris targets, need to use compatibility mode
21160       TAR_CREATE_EXTRA_PARAM="--format=ustar"
21161     fi
21162   else
21163     TAR_INCLUDE_PARAM="I"
21164     TAR_SUPPORTS_TRANSFORM="false"
21165   fi
21166 
21167 
21168 
21169 
21170 
21171 
21172   # These tools might not be installed by default,
21173   # need hint on how to install them.
21174 
21175 
21176 
21177   # Publish this variable in the help.
21178 
21179 
21180   if [ -z "${UNZIP+x}" ]; then
21181     # The variable is not set by user, try to locate tool using the code snippet
21182     for ac_prog in unzip
21183 do
21184   # Extract the first word of "$ac_prog", so it can be a program name with args.
21185 set dummy $ac_prog; ac_word=$2
21186 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21187 $as_echo_n "checking for $ac_word... " >&6; }
21188 if ${ac_cv_path_UNZIP+:} false; then :
21189   $as_echo_n "(cached) " >&6
21190 else
21191   case $UNZIP in
21192   [\\/]* | ?:[\\/]*)
21193   ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
21194   ;;
21195   *)
21196   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21197 for as_dir in $PATH
21198 do
21199   IFS=$as_save_IFS
21200   test -z "$as_dir" && as_dir=.
21201     for ac_exec_ext in '' $ac_executable_extensions; do
21202   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21203     ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
21204     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21205     break 2
21206   fi
21207 done
21208   done
21209 IFS=$as_save_IFS
21210 
21211   ;;
21212 esac
21213 fi
21214 UNZIP=$ac_cv_path_UNZIP
21215 if test -n "$UNZIP"; then
21216   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
21217 $as_echo "$UNZIP" >&6; }
21218 else
21219   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21220 $as_echo "no" >&6; }
21221 fi
21222 
21223 
21224   test -n "$UNZIP" && break
21225 done
21226 
21227   else
21228     # The variable is set, but is it from the command line or the environment?
21229 
21230     # Try to remove the string !UNZIP! from our list.
21231     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNZIP!/}
21232     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
21233       # If it failed, the variable was not from the command line. Ignore it,
21234       # but warn the user (except for BASH, which is always set by the calling BASH).
21235       if test "xUNZIP" != xBASH; then
21236         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNZIP from the environment. Use command line variables instead." >&5
21237 $as_echo "$as_me: WARNING: Ignoring value of UNZIP from the environment. Use command line variables instead." >&2;}
21238       fi
21239       # Try to locate tool using the code snippet
21240       for ac_prog in unzip
21241 do
21242   # Extract the first word of "$ac_prog", so it can be a program name with args.
21243 set dummy $ac_prog; ac_word=$2
21244 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21245 $as_echo_n "checking for $ac_word... " >&6; }
21246 if ${ac_cv_path_UNZIP+:} false; then :
21247   $as_echo_n "(cached) " >&6
21248 else
21249   case $UNZIP in
21250   [\\/]* | ?:[\\/]*)
21251   ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
21252   ;;
21253   *)
21254   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21255 for as_dir in $PATH
21256 do
21257   IFS=$as_save_IFS
21258   test -z "$as_dir" && as_dir=.
21259     for ac_exec_ext in '' $ac_executable_extensions; do
21260   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21261     ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
21262     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21263     break 2
21264   fi
21265 done
21266   done
21267 IFS=$as_save_IFS
21268 
21269   ;;
21270 esac
21271 fi
21272 UNZIP=$ac_cv_path_UNZIP
21273 if test -n "$UNZIP"; then
21274   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
21275 $as_echo "$UNZIP" >&6; }
21276 else
21277   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21278 $as_echo "no" >&6; }
21279 fi
21280 
21281 
21282   test -n "$UNZIP" && break
21283 done
21284 
21285     else
21286       # If it succeeded, then it was overridden by the user. We will use it
21287       # for the tool.
21288 
21289       # First remove it from the list of overridden variables, so we can test
21290       # for unknown variables in the end.
21291       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
21292 
21293       # Check if we try to supply an empty value
21294       if test "x$UNZIP" = x; then
21295         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool UNZIP= (no value)" >&5
21296 $as_echo "$as_me: Setting user supplied tool UNZIP= (no value)" >&6;}
21297         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNZIP" >&5
21298 $as_echo_n "checking for UNZIP... " >&6; }
21299         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
21300 $as_echo "disabled" >&6; }
21301       else
21302         # Check if the provided tool contains a complete path.
21303         tool_specified="$UNZIP"
21304         tool_basename="${tool_specified##*/}"
21305         if test "x$tool_basename" = "x$tool_specified"; then
21306           # A command without a complete path is provided, search $PATH.
21307           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNZIP=$tool_basename" >&5
21308 $as_echo "$as_me: Will search for user supplied tool UNZIP=$tool_basename" >&6;}
21309           # Extract the first word of "$tool_basename", so it can be a program name with args.
21310 set dummy $tool_basename; ac_word=$2
21311 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21312 $as_echo_n "checking for $ac_word... " >&6; }
21313 if ${ac_cv_path_UNZIP+:} false; then :
21314   $as_echo_n "(cached) " >&6
21315 else
21316   case $UNZIP in
21317   [\\/]* | ?:[\\/]*)
21318   ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
21319   ;;
21320   *)
21321   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21322 for as_dir in $PATH
21323 do
21324   IFS=$as_save_IFS
21325   test -z "$as_dir" && as_dir=.
21326     for ac_exec_ext in '' $ac_executable_extensions; do
21327   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21328     ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
21329     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21330     break 2
21331   fi
21332 done
21333   done
21334 IFS=$as_save_IFS
21335 
21336   ;;
21337 esac
21338 fi
21339 UNZIP=$ac_cv_path_UNZIP
21340 if test -n "$UNZIP"; then
21341   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
21342 $as_echo "$UNZIP" >&6; }
21343 else
21344   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21345 $as_echo "no" >&6; }
21346 fi
21347 
21348 
21349           if test "x$UNZIP" = x; then
21350             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
21351           fi
21352         else
21353           # Otherwise we believe it is a complete path. Use it as it is.
21354           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNZIP=$tool_specified" >&5
21355 $as_echo "$as_me: Will use user supplied tool UNZIP=$tool_specified" >&6;}
21356           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNZIP" >&5
21357 $as_echo_n "checking for UNZIP... " >&6; }
21358           if test ! -x "$tool_specified"; then
21359             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
21360 $as_echo "not found" >&6; }
21361             as_fn_error $? "User supplied tool UNZIP=$tool_specified does not exist or is not executable" "$LINENO" 5
21362           fi
21363           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
21364 $as_echo "$tool_specified" >&6; }
21365         fi
21366       fi
21367     fi
21368 
21369   fi
21370 
21371 
21372 
21373   if test "x$UNZIP" = x; then
21374     as_fn_error $? "Could not find required tool for UNZIP" "$LINENO" 5
21375   fi
21376 
21377 
21378 
21379 
21380 
21381   # Publish this variable in the help.
21382 
21383 
21384   if [ -z "${ZIP+x}" ]; then
21385     # The variable is not set by user, try to locate tool using the code snippet
21386     for ac_prog in zip
21387 do
21388   # Extract the first word of "$ac_prog", so it can be a program name with args.
21389 set dummy $ac_prog; ac_word=$2
21390 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21391 $as_echo_n "checking for $ac_word... " >&6; }
21392 if ${ac_cv_path_ZIP+:} false; then :
21393   $as_echo_n "(cached) " >&6
21394 else
21395   case $ZIP in
21396   [\\/]* | ?:[\\/]*)
21397   ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
21398   ;;
21399   *)
21400   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21401 for as_dir in $PATH
21402 do
21403   IFS=$as_save_IFS
21404   test -z "$as_dir" && as_dir=.
21405     for ac_exec_ext in '' $ac_executable_extensions; do
21406   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21407     ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
21408     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21409     break 2
21410   fi
21411 done
21412   done
21413 IFS=$as_save_IFS
21414 
21415   ;;
21416 esac
21417 fi
21418 ZIP=$ac_cv_path_ZIP
21419 if test -n "$ZIP"; then
21420   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
21421 $as_echo "$ZIP" >&6; }
21422 else
21423   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21424 $as_echo "no" >&6; }
21425 fi
21426 
21427 
21428   test -n "$ZIP" && break
21429 done
21430 
21431   else
21432     # The variable is set, but is it from the command line or the environment?
21433 
21434     # Try to remove the string !ZIP! from our list.
21435     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!ZIP!/}
21436     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
21437       # If it failed, the variable was not from the command line. Ignore it,
21438       # but warn the user (except for BASH, which is always set by the calling BASH).
21439       if test "xZIP" != xBASH; then
21440         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ZIP from the environment. Use command line variables instead." >&5
21441 $as_echo "$as_me: WARNING: Ignoring value of ZIP from the environment. Use command line variables instead." >&2;}
21442       fi
21443       # Try to locate tool using the code snippet
21444       for ac_prog in zip
21445 do
21446   # Extract the first word of "$ac_prog", so it can be a program name with args.
21447 set dummy $ac_prog; ac_word=$2
21448 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21449 $as_echo_n "checking for $ac_word... " >&6; }
21450 if ${ac_cv_path_ZIP+:} false; then :
21451   $as_echo_n "(cached) " >&6
21452 else
21453   case $ZIP in
21454   [\\/]* | ?:[\\/]*)
21455   ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
21456   ;;
21457   *)
21458   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21459 for as_dir in $PATH
21460 do
21461   IFS=$as_save_IFS
21462   test -z "$as_dir" && as_dir=.
21463     for ac_exec_ext in '' $ac_executable_extensions; do
21464   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21465     ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
21466     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21467     break 2
21468   fi
21469 done
21470   done
21471 IFS=$as_save_IFS
21472 
21473   ;;
21474 esac
21475 fi
21476 ZIP=$ac_cv_path_ZIP
21477 if test -n "$ZIP"; then
21478   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
21479 $as_echo "$ZIP" >&6; }
21480 else
21481   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21482 $as_echo "no" >&6; }
21483 fi
21484 
21485 
21486   test -n "$ZIP" && break
21487 done
21488 
21489     else
21490       # If it succeeded, then it was overridden by the user. We will use it
21491       # for the tool.
21492 
21493       # First remove it from the list of overridden variables, so we can test
21494       # for unknown variables in the end.
21495       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
21496 
21497       # Check if we try to supply an empty value
21498       if test "x$ZIP" = x; then
21499         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool ZIP= (no value)" >&5
21500 $as_echo "$as_me: Setting user supplied tool ZIP= (no value)" >&6;}
21501         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ZIP" >&5
21502 $as_echo_n "checking for ZIP... " >&6; }
21503         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
21504 $as_echo "disabled" >&6; }
21505       else
21506         # Check if the provided tool contains a complete path.
21507         tool_specified="$ZIP"
21508         tool_basename="${tool_specified##*/}"
21509         if test "x$tool_basename" = "x$tool_specified"; then
21510           # A command without a complete path is provided, search $PATH.
21511           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ZIP=$tool_basename" >&5
21512 $as_echo "$as_me: Will search for user supplied tool ZIP=$tool_basename" >&6;}
21513           # Extract the first word of "$tool_basename", so it can be a program name with args.
21514 set dummy $tool_basename; ac_word=$2
21515 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21516 $as_echo_n "checking for $ac_word... " >&6; }
21517 if ${ac_cv_path_ZIP+:} false; then :
21518   $as_echo_n "(cached) " >&6
21519 else
21520   case $ZIP in
21521   [\\/]* | ?:[\\/]*)
21522   ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
21523   ;;
21524   *)
21525   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21526 for as_dir in $PATH
21527 do
21528   IFS=$as_save_IFS
21529   test -z "$as_dir" && as_dir=.
21530     for ac_exec_ext in '' $ac_executable_extensions; do
21531   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21532     ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
21533     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21534     break 2
21535   fi
21536 done
21537   done
21538 IFS=$as_save_IFS
21539 
21540   ;;
21541 esac
21542 fi
21543 ZIP=$ac_cv_path_ZIP
21544 if test -n "$ZIP"; then
21545   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
21546 $as_echo "$ZIP" >&6; }
21547 else
21548   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21549 $as_echo "no" >&6; }
21550 fi
21551 
21552 
21553           if test "x$ZIP" = x; then
21554             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
21555           fi
21556         else
21557           # Otherwise we believe it is a complete path. Use it as it is.
21558           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ZIP=$tool_specified" >&5
21559 $as_echo "$as_me: Will use user supplied tool ZIP=$tool_specified" >&6;}
21560           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ZIP" >&5
21561 $as_echo_n "checking for ZIP... " >&6; }
21562           if test ! -x "$tool_specified"; then
21563             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
21564 $as_echo "not found" >&6; }
21565             as_fn_error $? "User supplied tool ZIP=$tool_specified does not exist or is not executable" "$LINENO" 5
21566           fi
21567           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
21568 $as_echo "$tool_specified" >&6; }
21569         fi
21570       fi
21571     fi
21572 
21573   fi
21574 
21575 
21576 
21577   if test "x$ZIP" = x; then
21578     as_fn_error $? "Could not find required tool for ZIP" "$LINENO" 5
21579   fi
21580 
21581 
21582 
21583   # Non-required basic tools
21584 
21585 
21586 
21587   # Publish this variable in the help.
21588 
21589 
21590   if [ -z "${LDD+x}" ]; then
21591     # The variable is not set by user, try to locate tool using the code snippet
21592     for ac_prog in ldd
21593 do
21594   # Extract the first word of "$ac_prog", so it can be a program name with args.
21595 set dummy $ac_prog; ac_word=$2
21596 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21597 $as_echo_n "checking for $ac_word... " >&6; }
21598 if ${ac_cv_path_LDD+:} false; then :
21599   $as_echo_n "(cached) " >&6
21600 else
21601   case $LDD in
21602   [\\/]* | ?:[\\/]*)
21603   ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
21604   ;;
21605   *)
21606   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21607 for as_dir in $PATH
21608 do
21609   IFS=$as_save_IFS
21610   test -z "$as_dir" && as_dir=.
21611     for ac_exec_ext in '' $ac_executable_extensions; do
21612   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21613     ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
21614     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21615     break 2
21616   fi
21617 done
21618   done
21619 IFS=$as_save_IFS
21620 
21621   ;;
21622 esac
21623 fi
21624 LDD=$ac_cv_path_LDD
21625 if test -n "$LDD"; then
21626   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
21627 $as_echo "$LDD" >&6; }
21628 else
21629   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21630 $as_echo "no" >&6; }
21631 fi
21632 
21633 
21634   test -n "$LDD" && break
21635 done
21636 
21637   else
21638     # The variable is set, but is it from the command line or the environment?
21639 
21640     # Try to remove the string !LDD! from our list.
21641     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LDD!/}
21642     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
21643       # If it failed, the variable was not from the command line. Ignore it,
21644       # but warn the user (except for BASH, which is always set by the calling BASH).
21645       if test "xLDD" != xBASH; then
21646         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LDD from the environment. Use command line variables instead." >&5
21647 $as_echo "$as_me: WARNING: Ignoring value of LDD from the environment. Use command line variables instead." >&2;}
21648       fi
21649       # Try to locate tool using the code snippet
21650       for ac_prog in ldd
21651 do
21652   # Extract the first word of "$ac_prog", so it can be a program name with args.
21653 set dummy $ac_prog; ac_word=$2
21654 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21655 $as_echo_n "checking for $ac_word... " >&6; }
21656 if ${ac_cv_path_LDD+:} false; then :
21657   $as_echo_n "(cached) " >&6
21658 else
21659   case $LDD in
21660   [\\/]* | ?:[\\/]*)
21661   ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
21662   ;;
21663   *)
21664   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21665 for as_dir in $PATH
21666 do
21667   IFS=$as_save_IFS
21668   test -z "$as_dir" && as_dir=.
21669     for ac_exec_ext in '' $ac_executable_extensions; do
21670   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21671     ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
21672     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21673     break 2
21674   fi
21675 done
21676   done
21677 IFS=$as_save_IFS
21678 
21679   ;;
21680 esac
21681 fi
21682 LDD=$ac_cv_path_LDD
21683 if test -n "$LDD"; then
21684   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
21685 $as_echo "$LDD" >&6; }
21686 else
21687   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21688 $as_echo "no" >&6; }
21689 fi
21690 
21691 
21692   test -n "$LDD" && break
21693 done
21694 
21695     else
21696       # If it succeeded, then it was overridden by the user. We will use it
21697       # for the tool.
21698 
21699       # First remove it from the list of overridden variables, so we can test
21700       # for unknown variables in the end.
21701       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
21702 
21703       # Check if we try to supply an empty value
21704       if test "x$LDD" = x; then
21705         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool LDD= (no value)" >&5
21706 $as_echo "$as_me: Setting user supplied tool LDD= (no value)" >&6;}
21707         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LDD" >&5
21708 $as_echo_n "checking for LDD... " >&6; }
21709         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
21710 $as_echo "disabled" >&6; }
21711       else
21712         # Check if the provided tool contains a complete path.
21713         tool_specified="$LDD"
21714         tool_basename="${tool_specified##*/}"
21715         if test "x$tool_basename" = "x$tool_specified"; then
21716           # A command without a complete path is provided, search $PATH.
21717           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LDD=$tool_basename" >&5
21718 $as_echo "$as_me: Will search for user supplied tool LDD=$tool_basename" >&6;}
21719           # Extract the first word of "$tool_basename", so it can be a program name with args.
21720 set dummy $tool_basename; ac_word=$2
21721 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21722 $as_echo_n "checking for $ac_word... " >&6; }
21723 if ${ac_cv_path_LDD+:} false; then :
21724   $as_echo_n "(cached) " >&6
21725 else
21726   case $LDD in
21727   [\\/]* | ?:[\\/]*)
21728   ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
21729   ;;
21730   *)
21731   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21732 for as_dir in $PATH
21733 do
21734   IFS=$as_save_IFS
21735   test -z "$as_dir" && as_dir=.
21736     for ac_exec_ext in '' $ac_executable_extensions; do
21737   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21738     ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
21739     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21740     break 2
21741   fi
21742 done
21743   done
21744 IFS=$as_save_IFS
21745 
21746   ;;
21747 esac
21748 fi
21749 LDD=$ac_cv_path_LDD
21750 if test -n "$LDD"; then
21751   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
21752 $as_echo "$LDD" >&6; }
21753 else
21754   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21755 $as_echo "no" >&6; }
21756 fi
21757 
21758 
21759           if test "x$LDD" = x; then
21760             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
21761           fi
21762         else
21763           # Otherwise we believe it is a complete path. Use it as it is.
21764           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LDD=$tool_specified" >&5
21765 $as_echo "$as_me: Will use user supplied tool LDD=$tool_specified" >&6;}
21766           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LDD" >&5
21767 $as_echo_n "checking for LDD... " >&6; }
21768           if test ! -x "$tool_specified"; then
21769             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
21770 $as_echo "not found" >&6; }
21771             as_fn_error $? "User supplied tool LDD=$tool_specified does not exist or is not executable" "$LINENO" 5
21772           fi
21773           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
21774 $as_echo "$tool_specified" >&6; }
21775         fi
21776       fi
21777     fi
21778 
21779   fi
21780 
21781 
21782   if test "x$LDD" = "x"; then
21783     # List shared lib dependencies is used for
21784     # debug output and checking for forbidden dependencies.
21785     # We can build without it.
21786     LDD="true"
21787   fi
21788 
21789 
21790   # Publish this variable in the help.
21791 
21792 
21793   if [ -z "${OTOOL+x}" ]; then
21794     # The variable is not set by user, try to locate tool using the code snippet
21795     for ac_prog in otool
21796 do
21797   # Extract the first word of "$ac_prog", so it can be a program name with args.
21798 set dummy $ac_prog; ac_word=$2
21799 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21800 $as_echo_n "checking for $ac_word... " >&6; }
21801 if ${ac_cv_path_OTOOL+:} false; then :
21802   $as_echo_n "(cached) " >&6
21803 else
21804   case $OTOOL in
21805   [\\/]* | ?:[\\/]*)
21806   ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
21807   ;;
21808   *)
21809   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21810 for as_dir in $PATH
21811 do
21812   IFS=$as_save_IFS
21813   test -z "$as_dir" && as_dir=.
21814     for ac_exec_ext in '' $ac_executable_extensions; do
21815   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21816     ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
21817     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21818     break 2
21819   fi
21820 done
21821   done
21822 IFS=$as_save_IFS
21823 
21824   ;;
21825 esac
21826 fi
21827 OTOOL=$ac_cv_path_OTOOL
21828 if test -n "$OTOOL"; then
21829   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
21830 $as_echo "$OTOOL" >&6; }
21831 else
21832   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21833 $as_echo "no" >&6; }
21834 fi
21835 
21836 
21837   test -n "$OTOOL" && break
21838 done
21839 
21840   else
21841     # The variable is set, but is it from the command line or the environment?
21842 
21843     # Try to remove the string !OTOOL! from our list.
21844     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!OTOOL!/}
21845     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
21846       # If it failed, the variable was not from the command line. Ignore it,
21847       # but warn the user (except for BASH, which is always set by the calling BASH).
21848       if test "xOTOOL" != xBASH; then
21849         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of OTOOL from the environment. Use command line variables instead." >&5
21850 $as_echo "$as_me: WARNING: Ignoring value of OTOOL from the environment. Use command line variables instead." >&2;}
21851       fi
21852       # Try to locate tool using the code snippet
21853       for ac_prog in otool
21854 do
21855   # Extract the first word of "$ac_prog", so it can be a program name with args.
21856 set dummy $ac_prog; ac_word=$2
21857 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21858 $as_echo_n "checking for $ac_word... " >&6; }
21859 if ${ac_cv_path_OTOOL+:} false; then :
21860   $as_echo_n "(cached) " >&6
21861 else
21862   case $OTOOL in
21863   [\\/]* | ?:[\\/]*)
21864   ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
21865   ;;
21866   *)
21867   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21868 for as_dir in $PATH
21869 do
21870   IFS=$as_save_IFS
21871   test -z "$as_dir" && as_dir=.
21872     for ac_exec_ext in '' $ac_executable_extensions; do
21873   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21874     ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
21875     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21876     break 2
21877   fi
21878 done
21879   done
21880 IFS=$as_save_IFS
21881 
21882   ;;
21883 esac
21884 fi
21885 OTOOL=$ac_cv_path_OTOOL
21886 if test -n "$OTOOL"; then
21887   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
21888 $as_echo "$OTOOL" >&6; }
21889 else
21890   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21891 $as_echo "no" >&6; }
21892 fi
21893 
21894 
21895   test -n "$OTOOL" && break
21896 done
21897 
21898     else
21899       # If it succeeded, then it was overridden by the user. We will use it
21900       # for the tool.
21901 
21902       # First remove it from the list of overridden variables, so we can test
21903       # for unknown variables in the end.
21904       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
21905 
21906       # Check if we try to supply an empty value
21907       if test "x$OTOOL" = x; then
21908         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool OTOOL= (no value)" >&5
21909 $as_echo "$as_me: Setting user supplied tool OTOOL= (no value)" >&6;}
21910         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for OTOOL" >&5
21911 $as_echo_n "checking for OTOOL... " >&6; }
21912         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
21913 $as_echo "disabled" >&6; }
21914       else
21915         # Check if the provided tool contains a complete path.
21916         tool_specified="$OTOOL"
21917         tool_basename="${tool_specified##*/}"
21918         if test "x$tool_basename" = "x$tool_specified"; then
21919           # A command without a complete path is provided, search $PATH.
21920           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool OTOOL=$tool_basename" >&5
21921 $as_echo "$as_me: Will search for user supplied tool OTOOL=$tool_basename" >&6;}
21922           # Extract the first word of "$tool_basename", so it can be a program name with args.
21923 set dummy $tool_basename; ac_word=$2
21924 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21925 $as_echo_n "checking for $ac_word... " >&6; }
21926 if ${ac_cv_path_OTOOL+:} false; then :
21927   $as_echo_n "(cached) " >&6
21928 else
21929   case $OTOOL in
21930   [\\/]* | ?:[\\/]*)
21931   ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
21932   ;;
21933   *)
21934   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21935 for as_dir in $PATH
21936 do
21937   IFS=$as_save_IFS
21938   test -z "$as_dir" && as_dir=.
21939     for ac_exec_ext in '' $ac_executable_extensions; do
21940   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21941     ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
21942     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21943     break 2
21944   fi
21945 done
21946   done
21947 IFS=$as_save_IFS
21948 
21949   ;;
21950 esac
21951 fi
21952 OTOOL=$ac_cv_path_OTOOL
21953 if test -n "$OTOOL"; then
21954   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
21955 $as_echo "$OTOOL" >&6; }
21956 else
21957   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21958 $as_echo "no" >&6; }
21959 fi
21960 
21961 
21962           if test "x$OTOOL" = x; then
21963             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
21964           fi
21965         else
21966           # Otherwise we believe it is a complete path. Use it as it is.
21967           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool OTOOL=$tool_specified" >&5
21968 $as_echo "$as_me: Will use user supplied tool OTOOL=$tool_specified" >&6;}
21969           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for OTOOL" >&5
21970 $as_echo_n "checking for OTOOL... " >&6; }
21971           if test ! -x "$tool_specified"; then
21972             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
21973 $as_echo "not found" >&6; }
21974             as_fn_error $? "User supplied tool OTOOL=$tool_specified does not exist or is not executable" "$LINENO" 5
21975           fi
21976           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
21977 $as_echo "$tool_specified" >&6; }
21978         fi
21979       fi
21980     fi
21981 
21982   fi
21983 
21984 
21985   if test "x$OTOOL" = "x"; then
21986     OTOOL="true"
21987   fi
21988 
21989 
21990   # Publish this variable in the help.
21991 
21992 
21993   if [ -z "${READELF+x}" ]; then
21994     # The variable is not set by user, try to locate tool using the code snippet
21995     for ac_prog in greadelf readelf
21996 do
21997   # Extract the first word of "$ac_prog", so it can be a program name with args.
21998 set dummy $ac_prog; ac_word=$2
21999 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22000 $as_echo_n "checking for $ac_word... " >&6; }
22001 if ${ac_cv_path_READELF+:} false; then :
22002   $as_echo_n "(cached) " >&6
22003 else
22004   case $READELF in
22005   [\\/]* | ?:[\\/]*)
22006   ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
22007   ;;
22008   *)
22009   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22010 for as_dir in $PATH
22011 do
22012   IFS=$as_save_IFS
22013   test -z "$as_dir" && as_dir=.
22014     for ac_exec_ext in '' $ac_executable_extensions; do
22015   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22016     ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
22017     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22018     break 2
22019   fi
22020 done
22021   done
22022 IFS=$as_save_IFS
22023 
22024   ;;
22025 esac
22026 fi
22027 READELF=$ac_cv_path_READELF
22028 if test -n "$READELF"; then
22029   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
22030 $as_echo "$READELF" >&6; }
22031 else
22032   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22033 $as_echo "no" >&6; }
22034 fi
22035 
22036 
22037   test -n "$READELF" && break
22038 done
22039 
22040   else
22041     # The variable is set, but is it from the command line or the environment?
22042 
22043     # Try to remove the string !READELF! from our list.
22044     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!READELF!/}
22045     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
22046       # If it failed, the variable was not from the command line. Ignore it,
22047       # but warn the user (except for BASH, which is always set by the calling BASH).
22048       if test "xREADELF" != xBASH; then
22049         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of READELF from the environment. Use command line variables instead." >&5
22050 $as_echo "$as_me: WARNING: Ignoring value of READELF from the environment. Use command line variables instead." >&2;}
22051       fi
22052       # Try to locate tool using the code snippet
22053       for ac_prog in greadelf readelf
22054 do
22055   # Extract the first word of "$ac_prog", so it can be a program name with args.
22056 set dummy $ac_prog; ac_word=$2
22057 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22058 $as_echo_n "checking for $ac_word... " >&6; }
22059 if ${ac_cv_path_READELF+:} false; then :
22060   $as_echo_n "(cached) " >&6
22061 else
22062   case $READELF in
22063   [\\/]* | ?:[\\/]*)
22064   ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
22065   ;;
22066   *)
22067   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22068 for as_dir in $PATH
22069 do
22070   IFS=$as_save_IFS
22071   test -z "$as_dir" && as_dir=.
22072     for ac_exec_ext in '' $ac_executable_extensions; do
22073   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22074     ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
22075     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22076     break 2
22077   fi
22078 done
22079   done
22080 IFS=$as_save_IFS
22081 
22082   ;;
22083 esac
22084 fi
22085 READELF=$ac_cv_path_READELF
22086 if test -n "$READELF"; then
22087   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
22088 $as_echo "$READELF" >&6; }
22089 else
22090   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22091 $as_echo "no" >&6; }
22092 fi
22093 
22094 
22095   test -n "$READELF" && break
22096 done
22097 
22098     else
22099       # If it succeeded, then it was overridden by the user. We will use it
22100       # for the tool.
22101 
22102       # First remove it from the list of overridden variables, so we can test
22103       # for unknown variables in the end.
22104       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
22105 
22106       # Check if we try to supply an empty value
22107       if test "x$READELF" = x; then
22108         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool READELF= (no value)" >&5
22109 $as_echo "$as_me: Setting user supplied tool READELF= (no value)" >&6;}
22110         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READELF" >&5
22111 $as_echo_n "checking for READELF... " >&6; }
22112         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
22113 $as_echo "disabled" >&6; }
22114       else
22115         # Check if the provided tool contains a complete path.
22116         tool_specified="$READELF"
22117         tool_basename="${tool_specified##*/}"
22118         if test "x$tool_basename" = "x$tool_specified"; then
22119           # A command without a complete path is provided, search $PATH.
22120           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool READELF=$tool_basename" >&5
22121 $as_echo "$as_me: Will search for user supplied tool READELF=$tool_basename" >&6;}
22122           # Extract the first word of "$tool_basename", so it can be a program name with args.
22123 set dummy $tool_basename; ac_word=$2
22124 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22125 $as_echo_n "checking for $ac_word... " >&6; }
22126 if ${ac_cv_path_READELF+:} false; then :
22127   $as_echo_n "(cached) " >&6
22128 else
22129   case $READELF in
22130   [\\/]* | ?:[\\/]*)
22131   ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
22132   ;;
22133   *)
22134   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22135 for as_dir in $PATH
22136 do
22137   IFS=$as_save_IFS
22138   test -z "$as_dir" && as_dir=.
22139     for ac_exec_ext in '' $ac_executable_extensions; do
22140   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22141     ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
22142     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22143     break 2
22144   fi
22145 done
22146   done
22147 IFS=$as_save_IFS
22148 
22149   ;;
22150 esac
22151 fi
22152 READELF=$ac_cv_path_READELF
22153 if test -n "$READELF"; then
22154   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
22155 $as_echo "$READELF" >&6; }
22156 else
22157   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22158 $as_echo "no" >&6; }
22159 fi
22160 
22161 
22162           if test "x$READELF" = x; then
22163             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
22164           fi
22165         else
22166           # Otherwise we believe it is a complete path. Use it as it is.
22167           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool READELF=$tool_specified" >&5
22168 $as_echo "$as_me: Will use user supplied tool READELF=$tool_specified" >&6;}
22169           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READELF" >&5
22170 $as_echo_n "checking for READELF... " >&6; }
22171           if test ! -x "$tool_specified"; then
22172             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
22173 $as_echo "not found" >&6; }
22174             as_fn_error $? "User supplied tool READELF=$tool_specified does not exist or is not executable" "$LINENO" 5
22175           fi
22176           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
22177 $as_echo "$tool_specified" >&6; }
22178         fi
22179       fi
22180     fi
22181 
22182   fi
22183 
22184 
22185 
22186 
22187   # Publish this variable in the help.
22188 
22189 
22190   if [ -z "${HG+x}" ]; then
22191     # The variable is not set by user, try to locate tool using the code snippet
22192     for ac_prog in hg
22193 do
22194   # Extract the first word of "$ac_prog", so it can be a program name with args.
22195 set dummy $ac_prog; ac_word=$2
22196 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22197 $as_echo_n "checking for $ac_word... " >&6; }
22198 if ${ac_cv_path_HG+:} false; then :
22199   $as_echo_n "(cached) " >&6
22200 else
22201   case $HG in
22202   [\\/]* | ?:[\\/]*)
22203   ac_cv_path_HG="$HG" # Let the user override the test with a path.
22204   ;;
22205   *)
22206   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22207 for as_dir in $PATH
22208 do
22209   IFS=$as_save_IFS
22210   test -z "$as_dir" && as_dir=.
22211     for ac_exec_ext in '' $ac_executable_extensions; do
22212   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22213     ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
22214     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22215     break 2
22216   fi
22217 done
22218   done
22219 IFS=$as_save_IFS
22220 
22221   ;;
22222 esac
22223 fi
22224 HG=$ac_cv_path_HG
22225 if test -n "$HG"; then
22226   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
22227 $as_echo "$HG" >&6; }
22228 else
22229   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22230 $as_echo "no" >&6; }
22231 fi
22232 
22233 
22234   test -n "$HG" && break
22235 done
22236 
22237   else
22238     # The variable is set, but is it from the command line or the environment?
22239 
22240     # Try to remove the string !HG! from our list.
22241     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!HG!/}
22242     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
22243       # If it failed, the variable was not from the command line. Ignore it,
22244       # but warn the user (except for BASH, which is always set by the calling BASH).
22245       if test "xHG" != xBASH; then
22246         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of HG from the environment. Use command line variables instead." >&5
22247 $as_echo "$as_me: WARNING: Ignoring value of HG from the environment. Use command line variables instead." >&2;}
22248       fi
22249       # Try to locate tool using the code snippet
22250       for ac_prog in hg
22251 do
22252   # Extract the first word of "$ac_prog", so it can be a program name with args.
22253 set dummy $ac_prog; ac_word=$2
22254 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22255 $as_echo_n "checking for $ac_word... " >&6; }
22256 if ${ac_cv_path_HG+:} false; then :
22257   $as_echo_n "(cached) " >&6
22258 else
22259   case $HG in
22260   [\\/]* | ?:[\\/]*)
22261   ac_cv_path_HG="$HG" # Let the user override the test with a path.
22262   ;;
22263   *)
22264   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22265 for as_dir in $PATH
22266 do
22267   IFS=$as_save_IFS
22268   test -z "$as_dir" && as_dir=.
22269     for ac_exec_ext in '' $ac_executable_extensions; do
22270   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22271     ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
22272     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22273     break 2
22274   fi
22275 done
22276   done
22277 IFS=$as_save_IFS
22278 
22279   ;;
22280 esac
22281 fi
22282 HG=$ac_cv_path_HG
22283 if test -n "$HG"; then
22284   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
22285 $as_echo "$HG" >&6; }
22286 else
22287   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22288 $as_echo "no" >&6; }
22289 fi
22290 
22291 
22292   test -n "$HG" && break
22293 done
22294 
22295     else
22296       # If it succeeded, then it was overridden by the user. We will use it
22297       # for the tool.
22298 
22299       # First remove it from the list of overridden variables, so we can test
22300       # for unknown variables in the end.
22301       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
22302 
22303       # Check if we try to supply an empty value
22304       if test "x$HG" = x; then
22305         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool HG= (no value)" >&5
22306 $as_echo "$as_me: Setting user supplied tool HG= (no value)" >&6;}
22307         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HG" >&5
22308 $as_echo_n "checking for HG... " >&6; }
22309         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
22310 $as_echo "disabled" >&6; }
22311       else
22312         # Check if the provided tool contains a complete path.
22313         tool_specified="$HG"
22314         tool_basename="${tool_specified##*/}"
22315         if test "x$tool_basename" = "x$tool_specified"; then
22316           # A command without a complete path is provided, search $PATH.
22317           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool HG=$tool_basename" >&5
22318 $as_echo "$as_me: Will search for user supplied tool HG=$tool_basename" >&6;}
22319           # Extract the first word of "$tool_basename", so it can be a program name with args.
22320 set dummy $tool_basename; ac_word=$2
22321 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22322 $as_echo_n "checking for $ac_word... " >&6; }
22323 if ${ac_cv_path_HG+:} false; then :
22324   $as_echo_n "(cached) " >&6
22325 else
22326   case $HG in
22327   [\\/]* | ?:[\\/]*)
22328   ac_cv_path_HG="$HG" # Let the user override the test with a path.
22329   ;;
22330   *)
22331   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22332 for as_dir in $PATH
22333 do
22334   IFS=$as_save_IFS
22335   test -z "$as_dir" && as_dir=.
22336     for ac_exec_ext in '' $ac_executable_extensions; do
22337   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22338     ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
22339     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22340     break 2
22341   fi
22342 done
22343   done
22344 IFS=$as_save_IFS
22345 
22346   ;;
22347 esac
22348 fi
22349 HG=$ac_cv_path_HG
22350 if test -n "$HG"; then
22351   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
22352 $as_echo "$HG" >&6; }
22353 else
22354   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22355 $as_echo "no" >&6; }
22356 fi
22357 
22358 
22359           if test "x$HG" = x; then
22360             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
22361           fi
22362         else
22363           # Otherwise we believe it is a complete path. Use it as it is.
22364           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool HG=$tool_specified" >&5
22365 $as_echo "$as_me: Will use user supplied tool HG=$tool_specified" >&6;}
22366           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HG" >&5
22367 $as_echo_n "checking for HG... " >&6; }
22368           if test ! -x "$tool_specified"; then
22369             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
22370 $as_echo "not found" >&6; }
22371             as_fn_error $? "User supplied tool HG=$tool_specified does not exist or is not executable" "$LINENO" 5
22372           fi
22373           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
22374 $as_echo "$tool_specified" >&6; }
22375         fi
22376       fi
22377     fi
22378 
22379   fi
22380 
22381 
22382 
22383 
22384   # Publish this variable in the help.
22385 
22386 
22387   if [ -z "${STAT+x}" ]; then
22388     # The variable is not set by user, try to locate tool using the code snippet
22389     for ac_prog in stat
22390 do
22391   # Extract the first word of "$ac_prog", so it can be a program name with args.
22392 set dummy $ac_prog; ac_word=$2
22393 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22394 $as_echo_n "checking for $ac_word... " >&6; }
22395 if ${ac_cv_path_STAT+:} false; then :
22396   $as_echo_n "(cached) " >&6
22397 else
22398   case $STAT in
22399   [\\/]* | ?:[\\/]*)
22400   ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
22401   ;;
22402   *)
22403   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22404 for as_dir in $PATH
22405 do
22406   IFS=$as_save_IFS
22407   test -z "$as_dir" && as_dir=.
22408     for ac_exec_ext in '' $ac_executable_extensions; do
22409   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22410     ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
22411     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22412     break 2
22413   fi
22414 done
22415   done
22416 IFS=$as_save_IFS
22417 
22418   ;;
22419 esac
22420 fi
22421 STAT=$ac_cv_path_STAT
22422 if test -n "$STAT"; then
22423   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
22424 $as_echo "$STAT" >&6; }
22425 else
22426   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22427 $as_echo "no" >&6; }
22428 fi
22429 
22430 
22431   test -n "$STAT" && break
22432 done
22433 
22434   else
22435     # The variable is set, but is it from the command line or the environment?
22436 
22437     # Try to remove the string !STAT! from our list.
22438     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!STAT!/}
22439     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
22440       # If it failed, the variable was not from the command line. Ignore it,
22441       # but warn the user (except for BASH, which is always set by the calling BASH).
22442       if test "xSTAT" != xBASH; then
22443         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of STAT from the environment. Use command line variables instead." >&5
22444 $as_echo "$as_me: WARNING: Ignoring value of STAT from the environment. Use command line variables instead." >&2;}
22445       fi
22446       # Try to locate tool using the code snippet
22447       for ac_prog in stat
22448 do
22449   # Extract the first word of "$ac_prog", so it can be a program name with args.
22450 set dummy $ac_prog; ac_word=$2
22451 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22452 $as_echo_n "checking for $ac_word... " >&6; }
22453 if ${ac_cv_path_STAT+:} false; then :
22454   $as_echo_n "(cached) " >&6
22455 else
22456   case $STAT in
22457   [\\/]* | ?:[\\/]*)
22458   ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
22459   ;;
22460   *)
22461   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22462 for as_dir in $PATH
22463 do
22464   IFS=$as_save_IFS
22465   test -z "$as_dir" && as_dir=.
22466     for ac_exec_ext in '' $ac_executable_extensions; do
22467   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22468     ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
22469     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22470     break 2
22471   fi
22472 done
22473   done
22474 IFS=$as_save_IFS
22475 
22476   ;;
22477 esac
22478 fi
22479 STAT=$ac_cv_path_STAT
22480 if test -n "$STAT"; then
22481   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
22482 $as_echo "$STAT" >&6; }
22483 else
22484   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22485 $as_echo "no" >&6; }
22486 fi
22487 
22488 
22489   test -n "$STAT" && break
22490 done
22491 
22492     else
22493       # If it succeeded, then it was overridden by the user. We will use it
22494       # for the tool.
22495 
22496       # First remove it from the list of overridden variables, so we can test
22497       # for unknown variables in the end.
22498       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
22499 
22500       # Check if we try to supply an empty value
22501       if test "x$STAT" = x; then
22502         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool STAT= (no value)" >&5
22503 $as_echo "$as_me: Setting user supplied tool STAT= (no value)" >&6;}
22504         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for STAT" >&5
22505 $as_echo_n "checking for STAT... " >&6; }
22506         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
22507 $as_echo "disabled" >&6; }
22508       else
22509         # Check if the provided tool contains a complete path.
22510         tool_specified="$STAT"
22511         tool_basename="${tool_specified##*/}"
22512         if test "x$tool_basename" = "x$tool_specified"; then
22513           # A command without a complete path is provided, search $PATH.
22514           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool STAT=$tool_basename" >&5
22515 $as_echo "$as_me: Will search for user supplied tool STAT=$tool_basename" >&6;}
22516           # Extract the first word of "$tool_basename", so it can be a program name with args.
22517 set dummy $tool_basename; ac_word=$2
22518 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22519 $as_echo_n "checking for $ac_word... " >&6; }
22520 if ${ac_cv_path_STAT+:} false; then :
22521   $as_echo_n "(cached) " >&6
22522 else
22523   case $STAT in
22524   [\\/]* | ?:[\\/]*)
22525   ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
22526   ;;
22527   *)
22528   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22529 for as_dir in $PATH
22530 do
22531   IFS=$as_save_IFS
22532   test -z "$as_dir" && as_dir=.
22533     for ac_exec_ext in '' $ac_executable_extensions; do
22534   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22535     ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
22536     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22537     break 2
22538   fi
22539 done
22540   done
22541 IFS=$as_save_IFS
22542 
22543   ;;
22544 esac
22545 fi
22546 STAT=$ac_cv_path_STAT
22547 if test -n "$STAT"; then
22548   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
22549 $as_echo "$STAT" >&6; }
22550 else
22551   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22552 $as_echo "no" >&6; }
22553 fi
22554 
22555 
22556           if test "x$STAT" = x; then
22557             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
22558           fi
22559         else
22560           # Otherwise we believe it is a complete path. Use it as it is.
22561           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool STAT=$tool_specified" >&5
22562 $as_echo "$as_me: Will use user supplied tool STAT=$tool_specified" >&6;}
22563           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for STAT" >&5
22564 $as_echo_n "checking for STAT... " >&6; }
22565           if test ! -x "$tool_specified"; then
22566             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
22567 $as_echo "not found" >&6; }
22568             as_fn_error $? "User supplied tool STAT=$tool_specified does not exist or is not executable" "$LINENO" 5
22569           fi
22570           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
22571 $as_echo "$tool_specified" >&6; }
22572         fi
22573       fi
22574     fi
22575 
22576   fi
22577 
22578 
22579 
22580 
22581   # Publish this variable in the help.
22582 
22583 
22584   if [ -z "${TIME+x}" ]; then
22585     # The variable is not set by user, try to locate tool using the code snippet
22586     for ac_prog in time
22587 do
22588   # Extract the first word of "$ac_prog", so it can be a program name with args.
22589 set dummy $ac_prog; ac_word=$2
22590 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22591 $as_echo_n "checking for $ac_word... " >&6; }
22592 if ${ac_cv_path_TIME+:} false; then :
22593   $as_echo_n "(cached) " >&6
22594 else
22595   case $TIME in
22596   [\\/]* | ?:[\\/]*)
22597   ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
22598   ;;
22599   *)
22600   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22601 for as_dir in $PATH
22602 do
22603   IFS=$as_save_IFS
22604   test -z "$as_dir" && as_dir=.
22605     for ac_exec_ext in '' $ac_executable_extensions; do
22606   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22607     ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
22608     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22609     break 2
22610   fi
22611 done
22612   done
22613 IFS=$as_save_IFS
22614 
22615   ;;
22616 esac
22617 fi
22618 TIME=$ac_cv_path_TIME
22619 if test -n "$TIME"; then
22620   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
22621 $as_echo "$TIME" >&6; }
22622 else
22623   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22624 $as_echo "no" >&6; }
22625 fi
22626 
22627 
22628   test -n "$TIME" && break
22629 done
22630 
22631   else
22632     # The variable is set, but is it from the command line or the environment?
22633 
22634     # Try to remove the string !TIME! from our list.
22635     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TIME!/}
22636     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
22637       # If it failed, the variable was not from the command line. Ignore it,
22638       # but warn the user (except for BASH, which is always set by the calling BASH).
22639       if test "xTIME" != xBASH; then
22640         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TIME from the environment. Use command line variables instead." >&5
22641 $as_echo "$as_me: WARNING: Ignoring value of TIME from the environment. Use command line variables instead." >&2;}
22642       fi
22643       # Try to locate tool using the code snippet
22644       for ac_prog in time
22645 do
22646   # Extract the first word of "$ac_prog", so it can be a program name with args.
22647 set dummy $ac_prog; ac_word=$2
22648 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22649 $as_echo_n "checking for $ac_word... " >&6; }
22650 if ${ac_cv_path_TIME+:} false; then :
22651   $as_echo_n "(cached) " >&6
22652 else
22653   case $TIME in
22654   [\\/]* | ?:[\\/]*)
22655   ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
22656   ;;
22657   *)
22658   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22659 for as_dir in $PATH
22660 do
22661   IFS=$as_save_IFS
22662   test -z "$as_dir" && as_dir=.
22663     for ac_exec_ext in '' $ac_executable_extensions; do
22664   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22665     ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
22666     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22667     break 2
22668   fi
22669 done
22670   done
22671 IFS=$as_save_IFS
22672 
22673   ;;
22674 esac
22675 fi
22676 TIME=$ac_cv_path_TIME
22677 if test -n "$TIME"; then
22678   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
22679 $as_echo "$TIME" >&6; }
22680 else
22681   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22682 $as_echo "no" >&6; }
22683 fi
22684 
22685 
22686   test -n "$TIME" && break
22687 done
22688 
22689     else
22690       # If it succeeded, then it was overridden by the user. We will use it
22691       # for the tool.
22692 
22693       # First remove it from the list of overridden variables, so we can test
22694       # for unknown variables in the end.
22695       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
22696 
22697       # Check if we try to supply an empty value
22698       if test "x$TIME" = x; then
22699         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool TIME= (no value)" >&5
22700 $as_echo "$as_me: Setting user supplied tool TIME= (no value)" >&6;}
22701         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TIME" >&5
22702 $as_echo_n "checking for TIME... " >&6; }
22703         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
22704 $as_echo "disabled" >&6; }
22705       else
22706         # Check if the provided tool contains a complete path.
22707         tool_specified="$TIME"
22708         tool_basename="${tool_specified##*/}"
22709         if test "x$tool_basename" = "x$tool_specified"; then
22710           # A command without a complete path is provided, search $PATH.
22711           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TIME=$tool_basename" >&5
22712 $as_echo "$as_me: Will search for user supplied tool TIME=$tool_basename" >&6;}
22713           # Extract the first word of "$tool_basename", so it can be a program name with args.
22714 set dummy $tool_basename; ac_word=$2
22715 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22716 $as_echo_n "checking for $ac_word... " >&6; }
22717 if ${ac_cv_path_TIME+:} false; then :
22718   $as_echo_n "(cached) " >&6
22719 else
22720   case $TIME in
22721   [\\/]* | ?:[\\/]*)
22722   ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
22723   ;;
22724   *)
22725   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22726 for as_dir in $PATH
22727 do
22728   IFS=$as_save_IFS
22729   test -z "$as_dir" && as_dir=.
22730     for ac_exec_ext in '' $ac_executable_extensions; do
22731   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22732     ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
22733     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22734     break 2
22735   fi
22736 done
22737   done
22738 IFS=$as_save_IFS
22739 
22740   ;;
22741 esac
22742 fi
22743 TIME=$ac_cv_path_TIME
22744 if test -n "$TIME"; then
22745   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
22746 $as_echo "$TIME" >&6; }
22747 else
22748   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22749 $as_echo "no" >&6; }
22750 fi
22751 
22752 
22753           if test "x$TIME" = x; then
22754             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
22755           fi
22756         else
22757           # Otherwise we believe it is a complete path. Use it as it is.
22758           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TIME=$tool_specified" >&5
22759 $as_echo "$as_me: Will use user supplied tool TIME=$tool_specified" >&6;}
22760           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TIME" >&5
22761 $as_echo_n "checking for TIME... " >&6; }
22762           if test ! -x "$tool_specified"; then
22763             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
22764 $as_echo "not found" >&6; }
22765             as_fn_error $? "User supplied tool TIME=$tool_specified does not exist or is not executable" "$LINENO" 5
22766           fi
22767           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
22768 $as_echo "$tool_specified" >&6; }
22769         fi
22770       fi
22771     fi
22772 
22773   fi
22774 
22775 
22776 
22777 
22778   # Publish this variable in the help.
22779 
22780 
22781   if [ -z "${DTRACE+x}" ]; then
22782     # The variable is not set by user, try to locate tool using the code snippet
22783     for ac_prog in dtrace
22784 do
22785   # Extract the first word of "$ac_prog", so it can be a program name with args.
22786 set dummy $ac_prog; ac_word=$2
22787 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22788 $as_echo_n "checking for $ac_word... " >&6; }
22789 if ${ac_cv_path_DTRACE+:} false; then :
22790   $as_echo_n "(cached) " >&6
22791 else
22792   case $DTRACE in
22793   [\\/]* | ?:[\\/]*)
22794   ac_cv_path_DTRACE="$DTRACE" # Let the user override the test with a path.
22795   ;;
22796   *)
22797   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22798 for as_dir in $PATH
22799 do
22800   IFS=$as_save_IFS
22801   test -z "$as_dir" && as_dir=.
22802     for ac_exec_ext in '' $ac_executable_extensions; do
22803   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22804     ac_cv_path_DTRACE="$as_dir/$ac_word$ac_exec_ext"
22805     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22806     break 2
22807   fi
22808 done
22809   done
22810 IFS=$as_save_IFS
22811 
22812   ;;
22813 esac
22814 fi
22815 DTRACE=$ac_cv_path_DTRACE
22816 if test -n "$DTRACE"; then
22817   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DTRACE" >&5
22818 $as_echo "$DTRACE" >&6; }
22819 else
22820   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22821 $as_echo "no" >&6; }
22822 fi
22823 
22824 
22825   test -n "$DTRACE" && break
22826 done
22827 
22828   else
22829     # The variable is set, but is it from the command line or the environment?
22830 
22831     # Try to remove the string !DTRACE! from our list.
22832     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DTRACE!/}
22833     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
22834       # If it failed, the variable was not from the command line. Ignore it,
22835       # but warn the user (except for BASH, which is always set by the calling BASH).
22836       if test "xDTRACE" != xBASH; then
22837         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DTRACE from the environment. Use command line variables instead." >&5
22838 $as_echo "$as_me: WARNING: Ignoring value of DTRACE from the environment. Use command line variables instead." >&2;}
22839       fi
22840       # Try to locate tool using the code snippet
22841       for ac_prog in dtrace
22842 do
22843   # Extract the first word of "$ac_prog", so it can be a program name with args.
22844 set dummy $ac_prog; ac_word=$2
22845 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22846 $as_echo_n "checking for $ac_word... " >&6; }
22847 if ${ac_cv_path_DTRACE+:} false; then :
22848   $as_echo_n "(cached) " >&6
22849 else
22850   case $DTRACE in
22851   [\\/]* | ?:[\\/]*)
22852   ac_cv_path_DTRACE="$DTRACE" # Let the user override the test with a path.
22853   ;;
22854   *)
22855   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22856 for as_dir in $PATH
22857 do
22858   IFS=$as_save_IFS
22859   test -z "$as_dir" && as_dir=.
22860     for ac_exec_ext in '' $ac_executable_extensions; do
22861   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22862     ac_cv_path_DTRACE="$as_dir/$ac_word$ac_exec_ext"
22863     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22864     break 2
22865   fi
22866 done
22867   done
22868 IFS=$as_save_IFS
22869 
22870   ;;
22871 esac
22872 fi
22873 DTRACE=$ac_cv_path_DTRACE
22874 if test -n "$DTRACE"; then
22875   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DTRACE" >&5
22876 $as_echo "$DTRACE" >&6; }
22877 else
22878   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22879 $as_echo "no" >&6; }
22880 fi
22881 
22882 
22883   test -n "$DTRACE" && break
22884 done
22885 
22886     else
22887       # If it succeeded, then it was overridden by the user. We will use it
22888       # for the tool.
22889 
22890       # First remove it from the list of overridden variables, so we can test
22891       # for unknown variables in the end.
22892       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
22893 
22894       # Check if we try to supply an empty value
22895       if test "x$DTRACE" = x; then
22896         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool DTRACE= (no value)" >&5
22897 $as_echo "$as_me: Setting user supplied tool DTRACE= (no value)" >&6;}
22898         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DTRACE" >&5
22899 $as_echo_n "checking for DTRACE... " >&6; }
22900         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
22901 $as_echo "disabled" >&6; }
22902       else
22903         # Check if the provided tool contains a complete path.
22904         tool_specified="$DTRACE"
22905         tool_basename="${tool_specified##*/}"
22906         if test "x$tool_basename" = "x$tool_specified"; then
22907           # A command without a complete path is provided, search $PATH.
22908           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DTRACE=$tool_basename" >&5
22909 $as_echo "$as_me: Will search for user supplied tool DTRACE=$tool_basename" >&6;}
22910           # Extract the first word of "$tool_basename", so it can be a program name with args.
22911 set dummy $tool_basename; ac_word=$2
22912 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22913 $as_echo_n "checking for $ac_word... " >&6; }
22914 if ${ac_cv_path_DTRACE+:} false; then :
22915   $as_echo_n "(cached) " >&6
22916 else
22917   case $DTRACE in
22918   [\\/]* | ?:[\\/]*)
22919   ac_cv_path_DTRACE="$DTRACE" # Let the user override the test with a path.
22920   ;;
22921   *)
22922   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22923 for as_dir in $PATH
22924 do
22925   IFS=$as_save_IFS
22926   test -z "$as_dir" && as_dir=.
22927     for ac_exec_ext in '' $ac_executable_extensions; do
22928   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22929     ac_cv_path_DTRACE="$as_dir/$ac_word$ac_exec_ext"
22930     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22931     break 2
22932   fi
22933 done
22934   done
22935 IFS=$as_save_IFS
22936 
22937   ;;
22938 esac
22939 fi
22940 DTRACE=$ac_cv_path_DTRACE
22941 if test -n "$DTRACE"; then
22942   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DTRACE" >&5
22943 $as_echo "$DTRACE" >&6; }
22944 else
22945   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22946 $as_echo "no" >&6; }
22947 fi
22948 
22949 
22950           if test "x$DTRACE" = x; then
22951             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
22952           fi
22953         else
22954           # Otherwise we believe it is a complete path. Use it as it is.
22955           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DTRACE=$tool_specified" >&5
22956 $as_echo "$as_me: Will use user supplied tool DTRACE=$tool_specified" >&6;}
22957           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DTRACE" >&5
22958 $as_echo_n "checking for DTRACE... " >&6; }
22959           if test ! -x "$tool_specified"; then
22960             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
22961 $as_echo "not found" >&6; }
22962             as_fn_error $? "User supplied tool DTRACE=$tool_specified does not exist or is not executable" "$LINENO" 5
22963           fi
22964           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
22965 $as_echo "$tool_specified" >&6; }
22966         fi
22967       fi
22968     fi
22969 
22970   fi
22971 
22972 
22973 
22974 
22975   # Publish this variable in the help.
22976 
22977 
22978   if [ -z "${PATCH+x}" ]; then
22979     # The variable is not set by user, try to locate tool using the code snippet
22980     for ac_prog in gpatch patch
22981 do
22982   # Extract the first word of "$ac_prog", so it can be a program name with args.
22983 set dummy $ac_prog; ac_word=$2
22984 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22985 $as_echo_n "checking for $ac_word... " >&6; }
22986 if ${ac_cv_path_PATCH+:} false; then :
22987   $as_echo_n "(cached) " >&6
22988 else
22989   case $PATCH in
22990   [\\/]* | ?:[\\/]*)
22991   ac_cv_path_PATCH="$PATCH" # Let the user override the test with a path.
22992   ;;
22993   *)
22994   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22995 for as_dir in $PATH
22996 do
22997   IFS=$as_save_IFS
22998   test -z "$as_dir" && as_dir=.
22999     for ac_exec_ext in '' $ac_executable_extensions; do
23000   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23001     ac_cv_path_PATCH="$as_dir/$ac_word$ac_exec_ext"
23002     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23003     break 2
23004   fi
23005 done
23006   done
23007 IFS=$as_save_IFS
23008 
23009   ;;
23010 esac
23011 fi
23012 PATCH=$ac_cv_path_PATCH
23013 if test -n "$PATCH"; then
23014   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PATCH" >&5
23015 $as_echo "$PATCH" >&6; }
23016 else
23017   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23018 $as_echo "no" >&6; }
23019 fi
23020 
23021 
23022   test -n "$PATCH" && break
23023 done
23024 
23025   else
23026     # The variable is set, but is it from the command line or the environment?
23027 
23028     # Try to remove the string !PATCH! from our list.
23029     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!PATCH!/}
23030     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
23031       # If it failed, the variable was not from the command line. Ignore it,
23032       # but warn the user (except for BASH, which is always set by the calling BASH).
23033       if test "xPATCH" != xBASH; then
23034         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of PATCH from the environment. Use command line variables instead." >&5
23035 $as_echo "$as_me: WARNING: Ignoring value of PATCH from the environment. Use command line variables instead." >&2;}
23036       fi
23037       # Try to locate tool using the code snippet
23038       for ac_prog in gpatch patch
23039 do
23040   # Extract the first word of "$ac_prog", so it can be a program name with args.
23041 set dummy $ac_prog; ac_word=$2
23042 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23043 $as_echo_n "checking for $ac_word... " >&6; }
23044 if ${ac_cv_path_PATCH+:} false; then :
23045   $as_echo_n "(cached) " >&6
23046 else
23047   case $PATCH in
23048   [\\/]* | ?:[\\/]*)
23049   ac_cv_path_PATCH="$PATCH" # Let the user override the test with a path.
23050   ;;
23051   *)
23052   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23053 for as_dir in $PATH
23054 do
23055   IFS=$as_save_IFS
23056   test -z "$as_dir" && as_dir=.
23057     for ac_exec_ext in '' $ac_executable_extensions; do
23058   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23059     ac_cv_path_PATCH="$as_dir/$ac_word$ac_exec_ext"
23060     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23061     break 2
23062   fi
23063 done
23064   done
23065 IFS=$as_save_IFS
23066 
23067   ;;
23068 esac
23069 fi
23070 PATCH=$ac_cv_path_PATCH
23071 if test -n "$PATCH"; then
23072   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PATCH" >&5
23073 $as_echo "$PATCH" >&6; }
23074 else
23075   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23076 $as_echo "no" >&6; }
23077 fi
23078 
23079 
23080   test -n "$PATCH" && break
23081 done
23082 
23083     else
23084       # If it succeeded, then it was overridden by the user. We will use it
23085       # for the tool.
23086 
23087       # First remove it from the list of overridden variables, so we can test
23088       # for unknown variables in the end.
23089       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
23090 
23091       # Check if we try to supply an empty value
23092       if test "x$PATCH" = x; then
23093         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool PATCH= (no value)" >&5
23094 $as_echo "$as_me: Setting user supplied tool PATCH= (no value)" >&6;}
23095         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PATCH" >&5
23096 $as_echo_n "checking for PATCH... " >&6; }
23097         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
23098 $as_echo "disabled" >&6; }
23099       else
23100         # Check if the provided tool contains a complete path.
23101         tool_specified="$PATCH"
23102         tool_basename="${tool_specified##*/}"
23103         if test "x$tool_basename" = "x$tool_specified"; then
23104           # A command without a complete path is provided, search $PATH.
23105           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool PATCH=$tool_basename" >&5
23106 $as_echo "$as_me: Will search for user supplied tool PATCH=$tool_basename" >&6;}
23107           # Extract the first word of "$tool_basename", so it can be a program name with args.
23108 set dummy $tool_basename; ac_word=$2
23109 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23110 $as_echo_n "checking for $ac_word... " >&6; }
23111 if ${ac_cv_path_PATCH+:} false; then :
23112   $as_echo_n "(cached) " >&6
23113 else
23114   case $PATCH in
23115   [\\/]* | ?:[\\/]*)
23116   ac_cv_path_PATCH="$PATCH" # Let the user override the test with a path.
23117   ;;
23118   *)
23119   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23120 for as_dir in $PATH
23121 do
23122   IFS=$as_save_IFS
23123   test -z "$as_dir" && as_dir=.
23124     for ac_exec_ext in '' $ac_executable_extensions; do
23125   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23126     ac_cv_path_PATCH="$as_dir/$ac_word$ac_exec_ext"
23127     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23128     break 2
23129   fi
23130 done
23131   done
23132 IFS=$as_save_IFS
23133 
23134   ;;
23135 esac
23136 fi
23137 PATCH=$ac_cv_path_PATCH
23138 if test -n "$PATCH"; then
23139   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PATCH" >&5
23140 $as_echo "$PATCH" >&6; }
23141 else
23142   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23143 $as_echo "no" >&6; }
23144 fi
23145 
23146 
23147           if test "x$PATCH" = x; then
23148             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
23149           fi
23150         else
23151           # Otherwise we believe it is a complete path. Use it as it is.
23152           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool PATCH=$tool_specified" >&5
23153 $as_echo "$as_me: Will use user supplied tool PATCH=$tool_specified" >&6;}
23154           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PATCH" >&5
23155 $as_echo_n "checking for PATCH... " >&6; }
23156           if test ! -x "$tool_specified"; then
23157             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
23158 $as_echo "not found" >&6; }
23159             as_fn_error $? "User supplied tool PATCH=$tool_specified does not exist or is not executable" "$LINENO" 5
23160           fi
23161           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
23162 $as_echo "$tool_specified" >&6; }
23163         fi
23164       fi
23165     fi
23166 
23167   fi
23168 
23169 
23170   # Check if it's GNU time
23171   IS_GNU_TIME=`$TIME --version 2>&1 | $GREP 'GNU time'`
23172   if test "x$IS_GNU_TIME" != x; then
23173     IS_GNU_TIME=yes
23174   else
23175     IS_GNU_TIME=no
23176   fi
23177 
23178 
23179   if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
23180 
23181 
23182 
23183   # Publish this variable in the help.
23184 
23185 
23186   if [ -z "${DSYMUTIL+x}" ]; then
23187     # The variable is not set by user, try to locate tool using the code snippet
23188     for ac_prog in dsymutil
23189 do
23190   # Extract the first word of "$ac_prog", so it can be a program name with args.
23191 set dummy $ac_prog; ac_word=$2
23192 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23193 $as_echo_n "checking for $ac_word... " >&6; }
23194 if ${ac_cv_path_DSYMUTIL+:} false; then :
23195   $as_echo_n "(cached) " >&6
23196 else
23197   case $DSYMUTIL in
23198   [\\/]* | ?:[\\/]*)
23199   ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
23200   ;;
23201   *)
23202   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23203 for as_dir in $PATH
23204 do
23205   IFS=$as_save_IFS
23206   test -z "$as_dir" && as_dir=.
23207     for ac_exec_ext in '' $ac_executable_extensions; do
23208   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23209     ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
23210     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23211     break 2
23212   fi
23213 done
23214   done
23215 IFS=$as_save_IFS
23216 
23217   ;;
23218 esac
23219 fi
23220 DSYMUTIL=$ac_cv_path_DSYMUTIL
23221 if test -n "$DSYMUTIL"; then
23222   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
23223 $as_echo "$DSYMUTIL" >&6; }
23224 else
23225   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23226 $as_echo "no" >&6; }
23227 fi
23228 
23229 
23230   test -n "$DSYMUTIL" && break
23231 done
23232 
23233   else
23234     # The variable is set, but is it from the command line or the environment?
23235 
23236     # Try to remove the string !DSYMUTIL! from our list.
23237     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DSYMUTIL!/}
23238     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
23239       # If it failed, the variable was not from the command line. Ignore it,
23240       # but warn the user (except for BASH, which is always set by the calling BASH).
23241       if test "xDSYMUTIL" != xBASH; then
23242         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DSYMUTIL from the environment. Use command line variables instead." >&5
23243 $as_echo "$as_me: WARNING: Ignoring value of DSYMUTIL from the environment. Use command line variables instead." >&2;}
23244       fi
23245       # Try to locate tool using the code snippet
23246       for ac_prog in dsymutil
23247 do
23248   # Extract the first word of "$ac_prog", so it can be a program name with args.
23249 set dummy $ac_prog; ac_word=$2
23250 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23251 $as_echo_n "checking for $ac_word... " >&6; }
23252 if ${ac_cv_path_DSYMUTIL+:} false; then :
23253   $as_echo_n "(cached) " >&6
23254 else
23255   case $DSYMUTIL in
23256   [\\/]* | ?:[\\/]*)
23257   ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
23258   ;;
23259   *)
23260   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23261 for as_dir in $PATH
23262 do
23263   IFS=$as_save_IFS
23264   test -z "$as_dir" && as_dir=.
23265     for ac_exec_ext in '' $ac_executable_extensions; do
23266   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23267     ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
23268     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23269     break 2
23270   fi
23271 done
23272   done
23273 IFS=$as_save_IFS
23274 
23275   ;;
23276 esac
23277 fi
23278 DSYMUTIL=$ac_cv_path_DSYMUTIL
23279 if test -n "$DSYMUTIL"; then
23280   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
23281 $as_echo "$DSYMUTIL" >&6; }
23282 else
23283   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23284 $as_echo "no" >&6; }
23285 fi
23286 
23287 
23288   test -n "$DSYMUTIL" && break
23289 done
23290 
23291     else
23292       # If it succeeded, then it was overridden by the user. We will use it
23293       # for the tool.
23294 
23295       # First remove it from the list of overridden variables, so we can test
23296       # for unknown variables in the end.
23297       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
23298 
23299       # Check if we try to supply an empty value
23300       if test "x$DSYMUTIL" = x; then
23301         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool DSYMUTIL= (no value)" >&5
23302 $as_echo "$as_me: Setting user supplied tool DSYMUTIL= (no value)" >&6;}
23303         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DSYMUTIL" >&5
23304 $as_echo_n "checking for DSYMUTIL... " >&6; }
23305         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
23306 $as_echo "disabled" >&6; }
23307       else
23308         # Check if the provided tool contains a complete path.
23309         tool_specified="$DSYMUTIL"
23310         tool_basename="${tool_specified##*/}"
23311         if test "x$tool_basename" = "x$tool_specified"; then
23312           # A command without a complete path is provided, search $PATH.
23313           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DSYMUTIL=$tool_basename" >&5
23314 $as_echo "$as_me: Will search for user supplied tool DSYMUTIL=$tool_basename" >&6;}
23315           # Extract the first word of "$tool_basename", so it can be a program name with args.
23316 set dummy $tool_basename; ac_word=$2
23317 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23318 $as_echo_n "checking for $ac_word... " >&6; }
23319 if ${ac_cv_path_DSYMUTIL+:} false; then :
23320   $as_echo_n "(cached) " >&6
23321 else
23322   case $DSYMUTIL in
23323   [\\/]* | ?:[\\/]*)
23324   ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
23325   ;;
23326   *)
23327   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23328 for as_dir in $PATH
23329 do
23330   IFS=$as_save_IFS
23331   test -z "$as_dir" && as_dir=.
23332     for ac_exec_ext in '' $ac_executable_extensions; do
23333   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23334     ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
23335     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23336     break 2
23337   fi
23338 done
23339   done
23340 IFS=$as_save_IFS
23341 
23342   ;;
23343 esac
23344 fi
23345 DSYMUTIL=$ac_cv_path_DSYMUTIL
23346 if test -n "$DSYMUTIL"; then
23347   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
23348 $as_echo "$DSYMUTIL" >&6; }
23349 else
23350   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23351 $as_echo "no" >&6; }
23352 fi
23353 
23354 
23355           if test "x$DSYMUTIL" = x; then
23356             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
23357           fi
23358         else
23359           # Otherwise we believe it is a complete path. Use it as it is.
23360           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DSYMUTIL=$tool_specified" >&5
23361 $as_echo "$as_me: Will use user supplied tool DSYMUTIL=$tool_specified" >&6;}
23362           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DSYMUTIL" >&5
23363 $as_echo_n "checking for DSYMUTIL... " >&6; }
23364           if test ! -x "$tool_specified"; then
23365             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
23366 $as_echo "not found" >&6; }
23367             as_fn_error $? "User supplied tool DSYMUTIL=$tool_specified does not exist or is not executable" "$LINENO" 5
23368           fi
23369           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
23370 $as_echo "$tool_specified" >&6; }
23371         fi
23372       fi
23373     fi
23374 
23375   fi
23376 
23377 
23378 
23379   if test "x$DSYMUTIL" = x; then
23380     as_fn_error $? "Could not find required tool for DSYMUTIL" "$LINENO" 5
23381   fi
23382 
23383 
23384 
23385 
23386 
23387   # Publish this variable in the help.
23388 
23389 
23390   if [ -z "${XATTR+x}" ]; then
23391     # The variable is not set by user, try to locate tool using the code snippet
23392     for ac_prog in xattr
23393 do
23394   # Extract the first word of "$ac_prog", so it can be a program name with args.
23395 set dummy $ac_prog; ac_word=$2
23396 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23397 $as_echo_n "checking for $ac_word... " >&6; }
23398 if ${ac_cv_path_XATTR+:} false; then :
23399   $as_echo_n "(cached) " >&6
23400 else
23401   case $XATTR in
23402   [\\/]* | ?:[\\/]*)
23403   ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
23404   ;;
23405   *)
23406   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23407 for as_dir in $PATH
23408 do
23409   IFS=$as_save_IFS
23410   test -z "$as_dir" && as_dir=.
23411     for ac_exec_ext in '' $ac_executable_extensions; do
23412   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23413     ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
23414     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23415     break 2
23416   fi
23417 done
23418   done
23419 IFS=$as_save_IFS
23420 
23421   ;;
23422 esac
23423 fi
23424 XATTR=$ac_cv_path_XATTR
23425 if test -n "$XATTR"; then
23426   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
23427 $as_echo "$XATTR" >&6; }
23428 else
23429   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23430 $as_echo "no" >&6; }
23431 fi
23432 
23433 
23434   test -n "$XATTR" && break
23435 done
23436 
23437   else
23438     # The variable is set, but is it from the command line or the environment?
23439 
23440     # Try to remove the string !XATTR! from our list.
23441     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!XATTR!/}
23442     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
23443       # If it failed, the variable was not from the command line. Ignore it,
23444       # but warn the user (except for BASH, which is always set by the calling BASH).
23445       if test "xXATTR" != xBASH; then
23446         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of XATTR from the environment. Use command line variables instead." >&5
23447 $as_echo "$as_me: WARNING: Ignoring value of XATTR from the environment. Use command line variables instead." >&2;}
23448       fi
23449       # Try to locate tool using the code snippet
23450       for ac_prog in xattr
23451 do
23452   # Extract the first word of "$ac_prog", so it can be a program name with args.
23453 set dummy $ac_prog; ac_word=$2
23454 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23455 $as_echo_n "checking for $ac_word... " >&6; }
23456 if ${ac_cv_path_XATTR+:} false; then :
23457   $as_echo_n "(cached) " >&6
23458 else
23459   case $XATTR in
23460   [\\/]* | ?:[\\/]*)
23461   ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
23462   ;;
23463   *)
23464   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23465 for as_dir in $PATH
23466 do
23467   IFS=$as_save_IFS
23468   test -z "$as_dir" && as_dir=.
23469     for ac_exec_ext in '' $ac_executable_extensions; do
23470   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23471     ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
23472     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23473     break 2
23474   fi
23475 done
23476   done
23477 IFS=$as_save_IFS
23478 
23479   ;;
23480 esac
23481 fi
23482 XATTR=$ac_cv_path_XATTR
23483 if test -n "$XATTR"; then
23484   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
23485 $as_echo "$XATTR" >&6; }
23486 else
23487   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23488 $as_echo "no" >&6; }
23489 fi
23490 
23491 
23492   test -n "$XATTR" && break
23493 done
23494 
23495     else
23496       # If it succeeded, then it was overridden by the user. We will use it
23497       # for the tool.
23498 
23499       # First remove it from the list of overridden variables, so we can test
23500       # for unknown variables in the end.
23501       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
23502 
23503       # Check if we try to supply an empty value
23504       if test "x$XATTR" = x; then
23505         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool XATTR= (no value)" >&5
23506 $as_echo "$as_me: Setting user supplied tool XATTR= (no value)" >&6;}
23507         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XATTR" >&5
23508 $as_echo_n "checking for XATTR... " >&6; }
23509         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
23510 $as_echo "disabled" >&6; }
23511       else
23512         # Check if the provided tool contains a complete path.
23513         tool_specified="$XATTR"
23514         tool_basename="${tool_specified##*/}"
23515         if test "x$tool_basename" = "x$tool_specified"; then
23516           # A command without a complete path is provided, search $PATH.
23517           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool XATTR=$tool_basename" >&5
23518 $as_echo "$as_me: Will search for user supplied tool XATTR=$tool_basename" >&6;}
23519           # Extract the first word of "$tool_basename", so it can be a program name with args.
23520 set dummy $tool_basename; ac_word=$2
23521 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23522 $as_echo_n "checking for $ac_word... " >&6; }
23523 if ${ac_cv_path_XATTR+:} false; then :
23524   $as_echo_n "(cached) " >&6
23525 else
23526   case $XATTR in
23527   [\\/]* | ?:[\\/]*)
23528   ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
23529   ;;
23530   *)
23531   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23532 for as_dir in $PATH
23533 do
23534   IFS=$as_save_IFS
23535   test -z "$as_dir" && as_dir=.
23536     for ac_exec_ext in '' $ac_executable_extensions; do
23537   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23538     ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
23539     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23540     break 2
23541   fi
23542 done
23543   done
23544 IFS=$as_save_IFS
23545 
23546   ;;
23547 esac
23548 fi
23549 XATTR=$ac_cv_path_XATTR
23550 if test -n "$XATTR"; then
23551   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
23552 $as_echo "$XATTR" >&6; }
23553 else
23554   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23555 $as_echo "no" >&6; }
23556 fi
23557 
23558 
23559           if test "x$XATTR" = x; then
23560             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
23561           fi
23562         else
23563           # Otherwise we believe it is a complete path. Use it as it is.
23564           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool XATTR=$tool_specified" >&5
23565 $as_echo "$as_me: Will use user supplied tool XATTR=$tool_specified" >&6;}
23566           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XATTR" >&5
23567 $as_echo_n "checking for XATTR... " >&6; }
23568           if test ! -x "$tool_specified"; then
23569             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
23570 $as_echo "not found" >&6; }
23571             as_fn_error $? "User supplied tool XATTR=$tool_specified does not exist or is not executable" "$LINENO" 5
23572           fi
23573           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
23574 $as_echo "$tool_specified" >&6; }
23575         fi
23576       fi
23577     fi
23578 
23579   fi
23580 
23581 
23582 
23583   if test "x$XATTR" = x; then
23584     as_fn_error $? "Could not find required tool for XATTR" "$LINENO" 5
23585   fi
23586 
23587 
23588 
23589 
23590   # Publish this variable in the help.
23591 
23592 
23593   if [ -z "${CODESIGN+x}" ]; then
23594     # The variable is not set by user, try to locate tool using the code snippet
23595     for ac_prog in codesign
23596 do
23597   # Extract the first word of "$ac_prog", so it can be a program name with args.
23598 set dummy $ac_prog; ac_word=$2
23599 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23600 $as_echo_n "checking for $ac_word... " >&6; }
23601 if ${ac_cv_path_CODESIGN+:} false; then :
23602   $as_echo_n "(cached) " >&6
23603 else
23604   case $CODESIGN in
23605   [\\/]* | ?:[\\/]*)
23606   ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
23607   ;;
23608   *)
23609   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23610 for as_dir in $PATH
23611 do
23612   IFS=$as_save_IFS
23613   test -z "$as_dir" && as_dir=.
23614     for ac_exec_ext in '' $ac_executable_extensions; do
23615   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23616     ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
23617     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23618     break 2
23619   fi
23620 done
23621   done
23622 IFS=$as_save_IFS
23623 
23624   ;;
23625 esac
23626 fi
23627 CODESIGN=$ac_cv_path_CODESIGN
23628 if test -n "$CODESIGN"; then
23629   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
23630 $as_echo "$CODESIGN" >&6; }
23631 else
23632   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23633 $as_echo "no" >&6; }
23634 fi
23635 
23636 
23637   test -n "$CODESIGN" && break
23638 done
23639 
23640   else
23641     # The variable is set, but is it from the command line or the environment?
23642 
23643     # Try to remove the string !CODESIGN! from our list.
23644     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CODESIGN!/}
23645     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
23646       # If it failed, the variable was not from the command line. Ignore it,
23647       # but warn the user (except for BASH, which is always set by the calling BASH).
23648       if test "xCODESIGN" != xBASH; then
23649         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CODESIGN from the environment. Use command line variables instead." >&5
23650 $as_echo "$as_me: WARNING: Ignoring value of CODESIGN from the environment. Use command line variables instead." >&2;}
23651       fi
23652       # Try to locate tool using the code snippet
23653       for ac_prog in codesign
23654 do
23655   # Extract the first word of "$ac_prog", so it can be a program name with args.
23656 set dummy $ac_prog; ac_word=$2
23657 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23658 $as_echo_n "checking for $ac_word... " >&6; }
23659 if ${ac_cv_path_CODESIGN+:} false; then :
23660   $as_echo_n "(cached) " >&6
23661 else
23662   case $CODESIGN in
23663   [\\/]* | ?:[\\/]*)
23664   ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
23665   ;;
23666   *)
23667   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23668 for as_dir in $PATH
23669 do
23670   IFS=$as_save_IFS
23671   test -z "$as_dir" && as_dir=.
23672     for ac_exec_ext in '' $ac_executable_extensions; do
23673   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23674     ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
23675     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23676     break 2
23677   fi
23678 done
23679   done
23680 IFS=$as_save_IFS
23681 
23682   ;;
23683 esac
23684 fi
23685 CODESIGN=$ac_cv_path_CODESIGN
23686 if test -n "$CODESIGN"; then
23687   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
23688 $as_echo "$CODESIGN" >&6; }
23689 else
23690   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23691 $as_echo "no" >&6; }
23692 fi
23693 
23694 
23695   test -n "$CODESIGN" && break
23696 done
23697 
23698     else
23699       # If it succeeded, then it was overridden by the user. We will use it
23700       # for the tool.
23701 
23702       # First remove it from the list of overridden variables, so we can test
23703       # for unknown variables in the end.
23704       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
23705 
23706       # Check if we try to supply an empty value
23707       if test "x$CODESIGN" = x; then
23708         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CODESIGN= (no value)" >&5
23709 $as_echo "$as_me: Setting user supplied tool CODESIGN= (no value)" >&6;}
23710         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CODESIGN" >&5
23711 $as_echo_n "checking for CODESIGN... " >&6; }
23712         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
23713 $as_echo "disabled" >&6; }
23714       else
23715         # Check if the provided tool contains a complete path.
23716         tool_specified="$CODESIGN"
23717         tool_basename="${tool_specified##*/}"
23718         if test "x$tool_basename" = "x$tool_specified"; then
23719           # A command without a complete path is provided, search $PATH.
23720           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CODESIGN=$tool_basename" >&5
23721 $as_echo "$as_me: Will search for user supplied tool CODESIGN=$tool_basename" >&6;}
23722           # Extract the first word of "$tool_basename", so it can be a program name with args.
23723 set dummy $tool_basename; ac_word=$2
23724 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23725 $as_echo_n "checking for $ac_word... " >&6; }
23726 if ${ac_cv_path_CODESIGN+:} false; then :
23727   $as_echo_n "(cached) " >&6
23728 else
23729   case $CODESIGN in
23730   [\\/]* | ?:[\\/]*)
23731   ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
23732   ;;
23733   *)
23734   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23735 for as_dir in $PATH
23736 do
23737   IFS=$as_save_IFS
23738   test -z "$as_dir" && as_dir=.
23739     for ac_exec_ext in '' $ac_executable_extensions; do
23740   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23741     ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
23742     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23743     break 2
23744   fi
23745 done
23746   done
23747 IFS=$as_save_IFS
23748 
23749   ;;
23750 esac
23751 fi
23752 CODESIGN=$ac_cv_path_CODESIGN
23753 if test -n "$CODESIGN"; then
23754   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
23755 $as_echo "$CODESIGN" >&6; }
23756 else
23757   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23758 $as_echo "no" >&6; }
23759 fi
23760 
23761 
23762           if test "x$CODESIGN" = x; then
23763             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
23764           fi
23765         else
23766           # Otherwise we believe it is a complete path. Use it as it is.
23767           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CODESIGN=$tool_specified" >&5
23768 $as_echo "$as_me: Will use user supplied tool CODESIGN=$tool_specified" >&6;}
23769           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CODESIGN" >&5
23770 $as_echo_n "checking for CODESIGN... " >&6; }
23771           if test ! -x "$tool_specified"; then
23772             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
23773 $as_echo "not found" >&6; }
23774             as_fn_error $? "User supplied tool CODESIGN=$tool_specified does not exist or is not executable" "$LINENO" 5
23775           fi
23776           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
23777 $as_echo "$tool_specified" >&6; }
23778         fi
23779       fi
23780     fi
23781 
23782   fi
23783 
23784 
23785     if test "x$CODESIGN" != "x"; then
23786       # Verify that the openjdk_codesign certificate is present
23787       { $as_echo "$as_me:${as_lineno-$LINENO}: checking if openjdk_codesign certificate is present" >&5
23788 $as_echo_n "checking if openjdk_codesign certificate is present... " >&6; }
23789       $RM codesign-testfile
23790       $TOUCH codesign-testfile
23791       $CODESIGN -s openjdk_codesign codesign-testfile 2>&5 >&5 || CODESIGN=
23792       $RM codesign-testfile
23793       if test "x$CODESIGN" = x; then
23794         { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23795 $as_echo "no" >&6; }
23796       else
23797         { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
23798 $as_echo "yes" >&6; }
23799       fi
23800     fi
23801 
23802 
23803 
23804   # Publish this variable in the help.
23805 
23806 
23807   if [ -z "${SETFILE+x}" ]; then
23808     # The variable is not set by user, try to locate tool using the code snippet
23809     for ac_prog in SetFile
23810 do
23811   # Extract the first word of "$ac_prog", so it can be a program name with args.
23812 set dummy $ac_prog; ac_word=$2
23813 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23814 $as_echo_n "checking for $ac_word... " >&6; }
23815 if ${ac_cv_path_SETFILE+:} false; then :
23816   $as_echo_n "(cached) " >&6
23817 else
23818   case $SETFILE in
23819   [\\/]* | ?:[\\/]*)
23820   ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
23821   ;;
23822   *)
23823   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23824 for as_dir in $PATH
23825 do
23826   IFS=$as_save_IFS
23827   test -z "$as_dir" && as_dir=.
23828     for ac_exec_ext in '' $ac_executable_extensions; do
23829   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23830     ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
23831     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23832     break 2
23833   fi
23834 done
23835   done
23836 IFS=$as_save_IFS
23837 
23838   ;;
23839 esac
23840 fi
23841 SETFILE=$ac_cv_path_SETFILE
23842 if test -n "$SETFILE"; then
23843   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
23844 $as_echo "$SETFILE" >&6; }
23845 else
23846   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23847 $as_echo "no" >&6; }
23848 fi
23849 
23850 
23851   test -n "$SETFILE" && break
23852 done
23853 
23854   else
23855     # The variable is set, but is it from the command line or the environment?
23856 
23857     # Try to remove the string !SETFILE! from our list.
23858     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SETFILE!/}
23859     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
23860       # If it failed, the variable was not from the command line. Ignore it,
23861       # but warn the user (except for BASH, which is always set by the calling BASH).
23862       if test "xSETFILE" != xBASH; then
23863         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SETFILE from the environment. Use command line variables instead." >&5
23864 $as_echo "$as_me: WARNING: Ignoring value of SETFILE from the environment. Use command line variables instead." >&2;}
23865       fi
23866       # Try to locate tool using the code snippet
23867       for ac_prog in SetFile
23868 do
23869   # Extract the first word of "$ac_prog", so it can be a program name with args.
23870 set dummy $ac_prog; ac_word=$2
23871 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23872 $as_echo_n "checking for $ac_word... " >&6; }
23873 if ${ac_cv_path_SETFILE+:} false; then :
23874   $as_echo_n "(cached) " >&6
23875 else
23876   case $SETFILE in
23877   [\\/]* | ?:[\\/]*)
23878   ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
23879   ;;
23880   *)
23881   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23882 for as_dir in $PATH
23883 do
23884   IFS=$as_save_IFS
23885   test -z "$as_dir" && as_dir=.
23886     for ac_exec_ext in '' $ac_executable_extensions; do
23887   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23888     ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
23889     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23890     break 2
23891   fi
23892 done
23893   done
23894 IFS=$as_save_IFS
23895 
23896   ;;
23897 esac
23898 fi
23899 SETFILE=$ac_cv_path_SETFILE
23900 if test -n "$SETFILE"; then
23901   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
23902 $as_echo "$SETFILE" >&6; }
23903 else
23904   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23905 $as_echo "no" >&6; }
23906 fi
23907 
23908 
23909   test -n "$SETFILE" && break
23910 done
23911 
23912     else
23913       # If it succeeded, then it was overridden by the user. We will use it
23914       # for the tool.
23915 
23916       # First remove it from the list of overridden variables, so we can test
23917       # for unknown variables in the end.
23918       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
23919 
23920       # Check if we try to supply an empty value
23921       if test "x$SETFILE" = x; then
23922         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool SETFILE= (no value)" >&5
23923 $as_echo "$as_me: Setting user supplied tool SETFILE= (no value)" >&6;}
23924         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SETFILE" >&5
23925 $as_echo_n "checking for SETFILE... " >&6; }
23926         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
23927 $as_echo "disabled" >&6; }
23928       else
23929         # Check if the provided tool contains a complete path.
23930         tool_specified="$SETFILE"
23931         tool_basename="${tool_specified##*/}"
23932         if test "x$tool_basename" = "x$tool_specified"; then
23933           # A command without a complete path is provided, search $PATH.
23934           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SETFILE=$tool_basename" >&5
23935 $as_echo "$as_me: Will search for user supplied tool SETFILE=$tool_basename" >&6;}
23936           # Extract the first word of "$tool_basename", so it can be a program name with args.
23937 set dummy $tool_basename; ac_word=$2
23938 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23939 $as_echo_n "checking for $ac_word... " >&6; }
23940 if ${ac_cv_path_SETFILE+:} false; then :
23941   $as_echo_n "(cached) " >&6
23942 else
23943   case $SETFILE in
23944   [\\/]* | ?:[\\/]*)
23945   ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
23946   ;;
23947   *)
23948   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23949 for as_dir in $PATH
23950 do
23951   IFS=$as_save_IFS
23952   test -z "$as_dir" && as_dir=.
23953     for ac_exec_ext in '' $ac_executable_extensions; do
23954   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23955     ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
23956     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23957     break 2
23958   fi
23959 done
23960   done
23961 IFS=$as_save_IFS
23962 
23963   ;;
23964 esac
23965 fi
23966 SETFILE=$ac_cv_path_SETFILE
23967 if test -n "$SETFILE"; then
23968   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
23969 $as_echo "$SETFILE" >&6; }
23970 else
23971   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23972 $as_echo "no" >&6; }
23973 fi
23974 
23975 
23976           if test "x$SETFILE" = x; then
23977             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
23978           fi
23979         else
23980           # Otherwise we believe it is a complete path. Use it as it is.
23981           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SETFILE=$tool_specified" >&5
23982 $as_echo "$as_me: Will use user supplied tool SETFILE=$tool_specified" >&6;}
23983           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SETFILE" >&5
23984 $as_echo_n "checking for SETFILE... " >&6; }
23985           if test ! -x "$tool_specified"; then
23986             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
23987 $as_echo "not found" >&6; }
23988             as_fn_error $? "User supplied tool SETFILE=$tool_specified does not exist or is not executable" "$LINENO" 5
23989           fi
23990           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
23991 $as_echo "$tool_specified" >&6; }
23992         fi
23993       fi
23994     fi
23995 
23996   fi
23997 
23998 
23999 
24000   if test "x$SETFILE" = x; then
24001     as_fn_error $? "Could not find required tool for SETFILE" "$LINENO" 5
24002   fi
24003 
24004 
24005   fi
24006 
24007 
24008   # Test if bash supports pipefail.
24009   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if bash supports pipefail" >&5
24010 $as_echo_n "checking if bash supports pipefail... " >&6; }
24011   if ${BASH} -c 'set -o pipefail'; then
24012     BASH_ARGS="$BASH_ARGS -o pipefail"
24013     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
24014 $as_echo "yes" >&6; }
24015   else
24016     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
24017 $as_echo "no" >&6; }
24018   fi
24019 
24020   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if bash supports errexit (-e)" >&5
24021 $as_echo_n "checking if bash supports errexit (-e)... " >&6; }
24022   if ${BASH} -e -c 'true'; then
24023     BASH_ARGS="$BASH_ARGS -e"
24024     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
24025 $as_echo "yes" >&6; }
24026   else
24027     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
24028 $as_echo "no" >&6; }
24029   fi
24030 
24031 
24032 
24033 
24034 # Check if pkg-config is available.
24035 
24036 
24037 if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then
24038         if test -n "$ac_tool_prefix"; then
24039   # Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args.
24040 set dummy ${ac_tool_prefix}pkg-config; ac_word=$2
24041 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
24042 $as_echo_n "checking for $ac_word... " >&6; }
24043 if ${ac_cv_path_PKG_CONFIG+:} false; then :
24044   $as_echo_n "(cached) " >&6
24045 else
24046   case $PKG_CONFIG in
24047   [\\/]* | ?:[\\/]*)
24048   ac_cv_path_PKG_CONFIG="$PKG_CONFIG" # Let the user override the test with a path.
24049   ;;
24050   *)
24051   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
24052 for as_dir in $PATH
24053 do
24054   IFS=$as_save_IFS
24055   test -z "$as_dir" && as_dir=.
24056     for ac_exec_ext in '' $ac_executable_extensions; do
24057   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
24058     ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
24059     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
24060     break 2
24061   fi
24062 done
24063   done
24064 IFS=$as_save_IFS
24065 
24066   ;;
24067 esac
24068 fi
24069 PKG_CONFIG=$ac_cv_path_PKG_CONFIG
24070 if test -n "$PKG_CONFIG"; then
24071   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
24072 $as_echo "$PKG_CONFIG" >&6; }
24073 else
24074   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
24075 $as_echo "no" >&6; }
24076 fi
24077 
24078 
24079 fi
24080 if test -z "$ac_cv_path_PKG_CONFIG"; then
24081   ac_pt_PKG_CONFIG=$PKG_CONFIG
24082   # Extract the first word of "pkg-config", so it can be a program name with args.
24083 set dummy pkg-config; ac_word=$2
24084 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
24085 $as_echo_n "checking for $ac_word... " >&6; }
24086 if ${ac_cv_path_ac_pt_PKG_CONFIG+:} false; then :
24087   $as_echo_n "(cached) " >&6
24088 else
24089   case $ac_pt_PKG_CONFIG in
24090   [\\/]* | ?:[\\/]*)
24091   ac_cv_path_ac_pt_PKG_CONFIG="$ac_pt_PKG_CONFIG" # Let the user override the test with a path.
24092   ;;
24093   *)
24094   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
24095 for as_dir in $PATH
24096 do
24097   IFS=$as_save_IFS
24098   test -z "$as_dir" && as_dir=.
24099     for ac_exec_ext in '' $ac_executable_extensions; do
24100   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
24101     ac_cv_path_ac_pt_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
24102     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
24103     break 2
24104   fi
24105 done
24106   done
24107 IFS=$as_save_IFS
24108 
24109   ;;
24110 esac
24111 fi
24112 ac_pt_PKG_CONFIG=$ac_cv_path_ac_pt_PKG_CONFIG
24113 if test -n "$ac_pt_PKG_CONFIG"; then
24114   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_pt_PKG_CONFIG" >&5
24115 $as_echo "$ac_pt_PKG_CONFIG" >&6; }
24116 else
24117   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
24118 $as_echo "no" >&6; }
24119 fi
24120 
24121   if test "x$ac_pt_PKG_CONFIG" = x; then
24122     PKG_CONFIG=""
24123   else
24124     case $cross_compiling:$ac_tool_warned in
24125 yes:)
24126 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
24127 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
24128 ac_tool_warned=yes ;;
24129 esac
24130     PKG_CONFIG=$ac_pt_PKG_CONFIG
24131   fi
24132 else
24133   PKG_CONFIG="$ac_cv_path_PKG_CONFIG"
24134 fi
24135 
24136 fi
24137 if test -n "$PKG_CONFIG"; then
24138         _pkg_min_version=0.9.0
24139         { $as_echo "$as_me:${as_lineno-$LINENO}: checking pkg-config is at least version $_pkg_min_version" >&5
24140 $as_echo_n "checking pkg-config is at least version $_pkg_min_version... " >&6; }
24141         if $PKG_CONFIG --atleast-pkgconfig-version $_pkg_min_version; then
24142                 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
24143 $as_echo "yes" >&6; }
24144         else
24145                 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
24146 $as_echo "no" >&6; }
24147                 PKG_CONFIG=""
24148         fi
24149 
24150 fi
24151 
24152 # After basic tools have been setup, we can check build os specific details.
24153 
24154   ###############################################################################
24155 
24156   # Note that this is the build platform OS version!
24157 
24158   OS_VERSION="`uname -r | ${SED} 's!\.! !g' | ${SED} 's!-! !g'`"
24159   OS_VERSION_MAJOR="`${ECHO} ${OS_VERSION} | ${CUT} -f 1 -d ' '`"
24160   OS_VERSION_MINOR="`${ECHO} ${OS_VERSION} | ${CUT} -f 2 -d ' '`"
24161   OS_VERSION_MICRO="`${ECHO} ${OS_VERSION} | ${CUT} -f 3 -d ' '`"
24162 
24163 
24164 
24165 
24166 
24167 # Misc basic settings
24168 
24169 
24170 # Check whether --with-default-make-target was given.
24171 if test "${with_default_make_target+set}" = set; then :
24172   withval=$with_default_make_target;
24173 fi
24174 
24175   if test "x$with_default_make_target" = "x" \
24176       || test "x$with_default_make_target" = "xyes"; then
24177     DEFAULT_MAKE_TARGET="exploded-image"
24178   elif test "x$with_default_make_target" = "xno"; then
24179     as_fn_error $? "--without-default-make-target is not a valid option" "$LINENO" 5
24180   else
24181     DEFAULT_MAKE_TARGET="$with_default_make_target"
24182   fi
24183 
24184 
24185 
24186 
24187 ###############################################################################
24188 #
24189 # Determine OpenJDK variants, options and version numbers.
24190 #
24191 ###############################################################################
24192 
24193 # We need build & target for this.
24194 
24195   # Should we build a JDK/JVM with headful support (ie a graphical ui)?
24196   # We always build headless support.
24197   { $as_echo "$as_me:${as_lineno-$LINENO}: checking headful support" >&5
24198 $as_echo_n "checking headful support... " >&6; }
24199   # Check whether --enable-headful was given.
24200 if test "${enable_headful+set}" = set; then :
24201   enableval=$enable_headful; SUPPORT_HEADFUL=${enable_headful}
24202 else
24203   SUPPORT_HEADFUL=yes
24204 fi
24205 
24206 
24207   SUPPORT_HEADLESS=yes
24208   BUILD_HEADLESS="BUILD_HEADLESS:=true"
24209 
24210   if test "x$SUPPORT_HEADFUL" = xyes; then
24211     # We are building both headful and headless.
24212     headful_msg="include support for both headful and headless"
24213   fi
24214 
24215   if test "x$SUPPORT_HEADFUL" = xno; then
24216     # Thus we are building headless only.
24217     BUILD_HEADLESS="BUILD_HEADLESS:=true"
24218     headful_msg="headless only"
24219   fi
24220 
24221   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $headful_msg" >&5
24222 $as_echo "$headful_msg" >&6; }
24223 
24224 
24225 
24226 
24227 
24228   # Choose cacerts source file
24229 
24230 # Check whether --with-cacerts-file was given.
24231 if test "${with_cacerts_file+set}" = set; then :
24232   withval=$with_cacerts_file;
24233 fi
24234 
24235   if test "x$with_cacerts_file" != x; then
24236     CACERTS_FILE=$with_cacerts_file
24237   fi
24238 
24239 
24240   # Enable or disable unlimited crypto
24241   # Check whether --enable-unlimited-crypto was given.
24242 if test "${enable_unlimited_crypto+set}" = set; then :
24243   enableval=$enable_unlimited_crypto;
24244 else
24245   enable_unlimited_crypto=no
24246 fi
24247 
24248   if test "x$enable_unlimited_crypto" = "xyes"; then
24249     UNLIMITED_CRYPTO=true
24250   else
24251     UNLIMITED_CRYPTO=false
24252   fi
24253 
24254 
24255   # Should we build the serviceability agent (SA)?
24256   INCLUDE_SA=true
24257   if   [[ " $JVM_VARIANTS " =~ " zero " ]]   ||   [[ " $JVM_VARIANTS " =~ " zeroshark " ]]  ; then
24258     INCLUDE_SA=false
24259   fi
24260   if test "x$OPENJDK_TARGET_OS" = xaix ; then
24261     INCLUDE_SA=false
24262   fi
24263 
24264 
24265   # Compress jars
24266   COMPRESS_JARS=false
24267 
24268 
24269 
24270   # Setup default copyright year. Mostly overridden when building close to a new year.
24271 
24272 # Check whether --with-copyright-year was given.
24273 if test "${with_copyright_year+set}" = set; then :
24274   withval=$with_copyright_year;
24275 fi
24276 
24277   if test "x$with_copyright_year" = xyes; then
24278     as_fn_error $? "Copyright year must have a value" "$LINENO" 5
24279   elif test "x$with_copyright_year" != x; then
24280     COPYRIGHT_YEAR="$with_copyright_year"
24281   else
24282     COPYRIGHT_YEAR=`$DATE +'%Y'`
24283   fi
24284 
24285 
24286 
24287   # Check whether --enable-keep-packaged-modules was given.
24288 if test "${enable_keep_packaged_modules+set}" = set; then :
24289   enableval=$enable_keep_packaged_modules;
24290 fi
24291 
24292 
24293   if test "x$enable_keep_packaged_modules" = "xyes"; then
24294     { $as_echo "$as_me:${as_lineno-$LINENO}: checking if packaged modules are kept" >&5
24295 $as_echo_n "checking if packaged modules are kept... " >&6; }
24296     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
24297 $as_echo "yes" >&6; }
24298     JLINK_KEEP_PACKAGED_MODULES=true
24299   elif test "x$enable_keep_packaged_modules" = "xno"; then
24300     { $as_echo "$as_me:${as_lineno-$LINENO}: checking if packaged modules are kept" >&5
24301 $as_echo_n "checking if packaged modules are kept... " >&6; }
24302     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
24303 $as_echo "no" >&6; }
24304     JLINK_KEEP_PACKAGED_MODULES=false
24305   elif test "x$enable_keep_packaged_modules" = "x"; then
24306     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes (default)" >&5
24307 $as_echo "yes (default)" >&6; }
24308     JLINK_KEEP_PACKAGED_MODULES=true
24309   else
24310     as_fn_error $? "--enable-keep-packaged-modules accepts no argument" "$LINENO" 5
24311   fi
24312 
24313 
24314 
24315 
24316   # Warn user that old version arguments are deprecated.
24317 
24318 
24319 # Check whether --with-milestone was given.
24320 if test "${with_milestone+set}" = set; then :
24321   withval=$with_milestone; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-milestone is deprecated and will be ignored." >&5
24322 $as_echo "$as_me: WARNING: Option --with-milestone is deprecated and will be ignored." >&2;}
24323 fi
24324 
24325 
24326 
24327 
24328 # Check whether --with-update-version was given.
24329 if test "${with_update_version+set}" = set; then :
24330   withval=$with_update_version; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-update-version is deprecated and will be ignored." >&5
24331 $as_echo "$as_me: WARNING: Option --with-update-version is deprecated and will be ignored." >&2;}
24332 fi
24333 
24334 
24335 
24336 
24337 # Check whether --with-user-release-suffix was given.
24338 if test "${with_user_release_suffix+set}" = set; then :
24339   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
24340 $as_echo "$as_me: WARNING: Option --with-user-release-suffix is deprecated and will be ignored." >&2;}
24341 fi
24342 
24343 
24344 
24345 
24346 # Check whether --with-build-number was given.
24347 if test "${with_build_number+set}" = set; then :
24348   withval=$with_build_number; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-build-number is deprecated and will be ignored." >&5
24349 $as_echo "$as_me: WARNING: Option --with-build-number is deprecated and will be ignored." >&2;}
24350 fi
24351 
24352 
24353 
24354   # Source the version numbers file
24355   . $AUTOCONF_DIR/version-numbers
24356 
24357   # Some non-version number information is set in that file
24358 
24359 
24360 
24361 
24362 
24363 
24364 
24365 
24366 
24367   # Override version from arguments
24368 
24369   # If --with-version-string is set, process it first. It is possible to
24370   # override parts with more specific flags, since these are processed later.
24371 
24372 # Check whether --with-version-string was given.
24373 if test "${with_version_string+set}" = set; then :
24374   withval=$with_version_string;
24375 fi
24376 
24377   if test "x$with_version_string" = xyes; then
24378     as_fn_error $? "--with-version-string must have a value" "$LINENO" 5
24379   elif test "x$with_version_string" != x; then
24380     # Additional [] needed to keep m4 from mangling shell constructs.
24381     if  [[ $with_version_string =~ ^([0-9]+)(\.([0-9]+))?(\.([0-9]+))?(\.([0-9]+))?(-([a-zA-Z]+))?((\+)([0-9]+)?(-([-a-zA-Z0-9.]+))?)?$ ]] ; then
24382       VERSION_MAJOR=${BASH_REMATCH[1]}
24383       VERSION_MINOR=${BASH_REMATCH[3]}
24384       VERSION_SECURITY=${BASH_REMATCH[5]}
24385       VERSION_PATCH=${BASH_REMATCH[7]}
24386       VERSION_PRE=${BASH_REMATCH[9]}
24387       version_plus_separator=${BASH_REMATCH[11]}
24388       VERSION_BUILD=${BASH_REMATCH[12]}
24389       VERSION_OPT=${BASH_REMATCH[14]}
24390       # Unspecified numerical fields are interpreted as 0.
24391       if test "x$VERSION_MINOR" = x; then
24392         VERSION_MINOR=0
24393       fi
24394       if test "x$VERSION_SECURITY" = x; then
24395         VERSION_SECURITY=0
24396       fi
24397       if test "x$VERSION_PATCH" = x; then
24398         VERSION_PATCH=0
24399       fi
24400       if test "x$version_plus_separator" != x \
24401           && test "x$VERSION_BUILD$VERSION_OPT" = x; then
24402         as_fn_error $? "Version string contains + but both 'BUILD' and 'OPT' are missing" "$LINENO" 5
24403       fi
24404       # Stop the version part process from setting default values.
24405       # We still allow them to explicitely override though.
24406       NO_DEFAULT_VERSION_PARTS=true
24407     else
24408       as_fn_error $? "--with-version-string fails to parse as a valid version string: $with_version_string" "$LINENO" 5
24409     fi
24410   fi
24411 
24412 
24413 # Check whether --with-version-pre was given.
24414 if test "${with_version_pre+set}" = set; then :
24415   withval=$with_version_pre; with_version_pre_present=true
24416 else
24417   with_version_pre_present=false
24418 fi
24419 
24420 
24421   if test "x$with_version_pre_present" = xtrue; then
24422     if test "x$with_version_pre" = xyes; then
24423       as_fn_error $? "--with-version-pre must have a value" "$LINENO" 5
24424     elif test "x$with_version_pre" = xno; then
24425       # Interpret --without-* as empty string instead of the literal "no"
24426       VERSION_PRE=
24427     else
24428       # Only [a-zA-Z] is allowed in the VERSION_PRE. Outer [ ] to quote m4.
24429        VERSION_PRE=`$ECHO "$with_version_pre" | $TR -c -d '[a-z][A-Z]'`
24430       if test "x$VERSION_PRE" != "x$with_version_pre"; then
24431         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: --with-version-pre value has been sanitized from '$with_version_pre' to '$VERSION_PRE'" >&5
24432 $as_echo "$as_me: WARNING: --with-version-pre value has been sanitized from '$with_version_pre' to '$VERSION_PRE'" >&2;}
24433       fi
24434     fi
24435   else
24436     if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
24437       # Default is to use "internal" as pre
24438       VERSION_PRE="internal"
24439     fi
24440   fi
24441 
24442 
24443 # Check whether --with-version-opt was given.
24444 if test "${with_version_opt+set}" = set; then :
24445   withval=$with_version_opt; with_version_opt_present=true
24446 else
24447   with_version_opt_present=false
24448 fi
24449 
24450 
24451   if test "x$with_version_opt_present" = xtrue; then
24452     if test "x$with_version_opt" = xyes; then
24453       as_fn_error $? "--with-version-opt must have a value" "$LINENO" 5
24454     elif test "x$with_version_opt" = xno; then
24455       # Interpret --without-* as empty string instead of the literal "no"
24456       VERSION_OPT=
24457     else
24458       # Only [-.a-zA-Z0-9] is allowed in the VERSION_OPT. Outer [ ] to quote m4.
24459        VERSION_OPT=`$ECHO "$with_version_opt" | $TR -c -d '[a-z][A-Z][0-9].-'`
24460       if test "x$VERSION_OPT" != "x$with_version_opt"; then
24461         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: --with-version-opt value has been sanitized from '$with_version_opt' to '$VERSION_OPT'" >&5
24462 $as_echo "$as_me: WARNING: --with-version-opt value has been sanitized from '$with_version_opt' to '$VERSION_OPT'" >&2;}
24463       fi
24464     fi
24465   else
24466     if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
24467       # Default is to calculate a string like this <timestamp>.<username>.<base dir name>
24468       timestamp=`$DATE '+%Y-%m-%d-%H%M%S'`
24469       # Outer [ ] to quote m4.
24470        basedirname=`$BASENAME "$TOPDIR" | $TR -d -c '[a-z][A-Z][0-9].-'`
24471       VERSION_OPT="$timestamp.$USERNAME.$basedirname"
24472     fi
24473   fi
24474 
24475 
24476 # Check whether --with-version-build was given.
24477 if test "${with_version_build+set}" = set; then :
24478   withval=$with_version_build; with_version_build_present=true
24479 else
24480   with_version_build_present=false
24481 fi
24482 
24483 
24484   if test "x$with_version_build_present" = xtrue; then
24485     if test "x$with_version_build" = xyes; then
24486       as_fn_error $? "--with-version-build must have a value" "$LINENO" 5
24487     elif test "x$with_version_build" = xno; then
24488       # Interpret --without-* as empty string instead of the literal "no"
24489       VERSION_BUILD=
24490     elif test "x$with_version_build" = x; then
24491       VERSION_BUILD=
24492     else
24493 
24494   # Additional [] needed to keep m4 from mangling shell constructs.
24495   if  ! [[ "$with_version_build" =~ ^0*([1-9][0-9]*)|(0)$ ]]  ; then
24496     as_fn_error $? "\"$with_version_build\" is not a valid numerical value for VERSION_BUILD" "$LINENO" 5
24497   fi
24498   # Extract the version number without leading zeros.
24499   cleaned_value=${BASH_REMATCH[1]}
24500   if test "x$cleaned_value" = x; then
24501     # Special case for zero
24502     cleaned_value=${BASH_REMATCH[2]}
24503   fi
24504 
24505   if test $cleaned_value -gt 255; then
24506     as_fn_error $? "VERSION_BUILD is given as $with_version_build. This is greater than 255 which is not allowed." "$LINENO" 5
24507   fi
24508   if test "x$cleaned_value" != "x$with_version_build"; then
24509     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Value for VERSION_BUILD has been sanitized from '$with_version_build' to '$cleaned_value'" >&5
24510 $as_echo "$as_me: WARNING: Value for VERSION_BUILD has been sanitized from '$with_version_build' to '$cleaned_value'" >&2;}
24511   fi
24512   VERSION_BUILD=$cleaned_value
24513 
24514     fi
24515   else
24516     if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
24517       # Default is to not have a build number.
24518       VERSION_BUILD=""
24519       # FIXME: Until all code can cope with an empty VERSION_BUILD, set it to 0.
24520       VERSION_BUILD=0
24521     fi
24522   fi
24523 
24524 
24525 # Check whether --with-version-major was given.
24526 if test "${with_version_major+set}" = set; then :
24527   withval=$with_version_major; with_version_major_present=true
24528 else
24529   with_version_major_present=false
24530 fi
24531 
24532 
24533   if test "x$with_version_major_present" = xtrue; then
24534     if test "x$with_version_major" = xyes; then
24535       as_fn_error $? "--with-version-major must have a value" "$LINENO" 5
24536     else
24537 
24538   # Additional [] needed to keep m4 from mangling shell constructs.
24539   if  ! [[ "$with_version_major" =~ ^0*([1-9][0-9]*)|(0)$ ]]  ; then
24540     as_fn_error $? "\"$with_version_major\" is not a valid numerical value for VERSION_MAJOR" "$LINENO" 5
24541   fi
24542   # Extract the version number without leading zeros.
24543   cleaned_value=${BASH_REMATCH[1]}
24544   if test "x$cleaned_value" = x; then
24545     # Special case for zero
24546     cleaned_value=${BASH_REMATCH[2]}
24547   fi
24548 
24549   if test $cleaned_value -gt 255; then
24550     as_fn_error $? "VERSION_MAJOR is given as $with_version_major. This is greater than 255 which is not allowed." "$LINENO" 5
24551   fi
24552   if test "x$cleaned_value" != "x$with_version_major"; then
24553     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Value for VERSION_MAJOR has been sanitized from '$with_version_major' to '$cleaned_value'" >&5
24554 $as_echo "$as_me: WARNING: Value for VERSION_MAJOR has been sanitized from '$with_version_major' to '$cleaned_value'" >&2;}
24555   fi
24556   VERSION_MAJOR=$cleaned_value
24557 
24558     fi
24559   else
24560     if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
24561       # Default is to get value from version-numbers
24562       VERSION_MAJOR="$DEFAULT_VERSION_MAJOR"
24563     fi
24564   fi
24565 
24566 
24567 # Check whether --with-version-minor was given.
24568 if test "${with_version_minor+set}" = set; then :
24569   withval=$with_version_minor; with_version_minor_present=true
24570 else
24571   with_version_minor_present=false
24572 fi
24573 
24574 
24575   if test "x$with_version_minor_present" = xtrue; then
24576     if test "x$with_version_minor" = xyes; then
24577       as_fn_error $? "--with-version-minor must have a value" "$LINENO" 5
24578     elif test "x$with_version_minor" = xno; then
24579       # Interpret --without-* as empty string (i.e. 0) instead of the literal "no"
24580       VERSION_MINOR=0
24581     elif test "x$with_version_minor" = x; then
24582       VERSION_MINOR=0
24583     else
24584 
24585   # Additional [] needed to keep m4 from mangling shell constructs.
24586   if  ! [[ "$with_version_minor" =~ ^0*([1-9][0-9]*)|(0)$ ]]  ; then
24587     as_fn_error $? "\"$with_version_minor\" is not a valid numerical value for VERSION_MINOR" "$LINENO" 5
24588   fi
24589   # Extract the version number without leading zeros.
24590   cleaned_value=${BASH_REMATCH[1]}
24591   if test "x$cleaned_value" = x; then
24592     # Special case for zero
24593     cleaned_value=${BASH_REMATCH[2]}
24594   fi
24595 
24596   if test $cleaned_value -gt 255; then
24597     as_fn_error $? "VERSION_MINOR is given as $with_version_minor. This is greater than 255 which is not allowed." "$LINENO" 5
24598   fi
24599   if test "x$cleaned_value" != "x$with_version_minor"; then
24600     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Value for VERSION_MINOR has been sanitized from '$with_version_minor' to '$cleaned_value'" >&5
24601 $as_echo "$as_me: WARNING: Value for VERSION_MINOR has been sanitized from '$with_version_minor' to '$cleaned_value'" >&2;}
24602   fi
24603   VERSION_MINOR=$cleaned_value
24604 
24605     fi
24606   else
24607     if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
24608       # Default is 0, if unspecified
24609       VERSION_MINOR=0
24610     fi
24611   fi
24612 
24613 
24614 # Check whether --with-version-security was given.
24615 if test "${with_version_security+set}" = set; then :
24616   withval=$with_version_security; with_version_security_present=true
24617 else
24618   with_version_security_present=false
24619 fi
24620 
24621 
24622   if test "x$with_version_security_present" = xtrue; then
24623     if test "x$with_version_security" = xyes; then
24624       as_fn_error $? "--with-version-security must have a value" "$LINENO" 5
24625     elif test "x$with_version_security" = xno; then
24626       # Interpret --without-* as empty string (i.e. 0) instead of the literal "no"
24627       VERSION_SECURITY=0
24628     elif test "x$with_version_security" = x; then
24629       VERSION_SECURITY=0
24630     else
24631 
24632   # Additional [] needed to keep m4 from mangling shell constructs.
24633   if  ! [[ "$with_version_security" =~ ^0*([1-9][0-9]*)|(0)$ ]]  ; then
24634     as_fn_error $? "\"$with_version_security\" is not a valid numerical value for VERSION_SECURITY" "$LINENO" 5
24635   fi
24636   # Extract the version number without leading zeros.
24637   cleaned_value=${BASH_REMATCH[1]}
24638   if test "x$cleaned_value" = x; then
24639     # Special case for zero
24640     cleaned_value=${BASH_REMATCH[2]}
24641   fi
24642 
24643   if test $cleaned_value -gt 255; then
24644     as_fn_error $? "VERSION_SECURITY is given as $with_version_security. This is greater than 255 which is not allowed." "$LINENO" 5
24645   fi
24646   if test "x$cleaned_value" != "x$with_version_security"; then
24647     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Value for VERSION_SECURITY has been sanitized from '$with_version_security' to '$cleaned_value'" >&5
24648 $as_echo "$as_me: WARNING: Value for VERSION_SECURITY has been sanitized from '$with_version_security' to '$cleaned_value'" >&2;}
24649   fi
24650   VERSION_SECURITY=$cleaned_value
24651 
24652     fi
24653   else
24654     if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
24655       # Default is 0, if unspecified
24656       VERSION_SECURITY=0
24657     fi
24658   fi
24659 
24660 
24661 # Check whether --with-version-patch was given.
24662 if test "${with_version_patch+set}" = set; then :
24663   withval=$with_version_patch; with_version_patch_present=true
24664 else
24665   with_version_patch_present=false
24666 fi
24667 
24668 
24669   if test "x$with_version_patch_present" = xtrue; then
24670     if test "x$with_version_patch" = xyes; then
24671       as_fn_error $? "--with-version-patch must have a value" "$LINENO" 5
24672     elif test "x$with_version_patch" = xno; then
24673       # Interpret --without-* as empty string (i.e. 0) instead of the literal "no"
24674       VERSION_PATCH=0
24675     elif test "x$with_version_patch" = x; then
24676       VERSION_PATCH=0
24677     else
24678 
24679   # Additional [] needed to keep m4 from mangling shell constructs.
24680   if  ! [[ "$with_version_patch" =~ ^0*([1-9][0-9]*)|(0)$ ]]  ; then
24681     as_fn_error $? "\"$with_version_patch\" is not a valid numerical value for VERSION_PATCH" "$LINENO" 5
24682   fi
24683   # Extract the version number without leading zeros.
24684   cleaned_value=${BASH_REMATCH[1]}
24685   if test "x$cleaned_value" = x; then
24686     # Special case for zero
24687     cleaned_value=${BASH_REMATCH[2]}
24688   fi
24689 
24690   if test $cleaned_value -gt 255; then
24691     as_fn_error $? "VERSION_PATCH is given as $with_version_patch. This is greater than 255 which is not allowed." "$LINENO" 5
24692   fi
24693   if test "x$cleaned_value" != "x$with_version_patch"; then
24694     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Value for VERSION_PATCH has been sanitized from '$with_version_patch' to '$cleaned_value'" >&5
24695 $as_echo "$as_me: WARNING: Value for VERSION_PATCH has been sanitized from '$with_version_patch' to '$cleaned_value'" >&2;}
24696   fi
24697   VERSION_PATCH=$cleaned_value
24698 
24699     fi
24700   else
24701     if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
24702       # Default is 0, if unspecified
24703       VERSION_PATCH=0
24704     fi
24705   fi
24706 
24707   # Calculate derived version properties
24708 
24709   # Set VERSION_IS_GA based on if VERSION_PRE has a value
24710   if test "x$VERSION_PRE" = x; then
24711     VERSION_IS_GA=true
24712   else
24713     VERSION_IS_GA=false
24714   fi
24715 
24716   # VERSION_NUMBER but always with exactly 4 positions, with 0 for empty positions.
24717   VERSION_NUMBER_FOUR_POSITIONS=$VERSION_MAJOR.$VERSION_MINOR.$VERSION_SECURITY.$VERSION_PATCH
24718 
24719   stripped_version_number=$VERSION_NUMBER_FOUR_POSITIONS
24720   # Strip trailing zeroes from stripped_version_number
24721   for i in 1 2 3 ; do stripped_version_number=${stripped_version_number%.0} ; done
24722   VERSION_NUMBER=$stripped_version_number
24723 
24724   # The complete version string, with additional build information
24725   if test "x$VERSION_BUILD$VERSION_OPT" = x; then
24726     VERSION_STRING=$VERSION_NUMBER${VERSION_PRE:+-$VERSION_PRE}
24727   else
24728     # If either build or opt is set, we need a + separator
24729     VERSION_STRING=$VERSION_NUMBER${VERSION_PRE:+-$VERSION_PRE}+$VERSION_BUILD${VERSION_OPT:+-$VERSION_OPT}
24730   fi
24731 
24732   # The short version string, just VERSION_NUMBER and PRE, if present.
24733   VERSION_SHORT=$VERSION_NUMBER${VERSION_PRE:+-$VERSION_PRE}
24734 
24735   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for version string" >&5
24736 $as_echo_n "checking for version string... " >&6; }
24737   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $VERSION_STRING" >&5
24738 $as_echo "$VERSION_STRING" >&6; }
24739 
24740 
24741 
24742 
24743 
24744 
24745 
24746 
24747 
24748 
24749 
24750 
24751 
24752 
24753 
24754 ###############################################################################
24755 #
24756 # Setup BootJDK, used to bootstrap the build.
24757 #
24758 ###############################################################################
24759 
24760 
24761   BOOT_JDK_FOUND=no
24762 
24763 # Check whether --with-boot-jdk was given.
24764 if test "${with_boot_jdk+set}" = set; then :
24765   withval=$with_boot_jdk;
24766 fi
24767 
24768 
24769   # We look for the Boot JDK through various means, going from more certain to
24770   # more of a guess-work. After each test, BOOT_JDK_FOUND is set to "yes" if
24771   # we detected something (if so, the path to the jdk is in BOOT_JDK). But we
24772   # must check if this is indeed valid; otherwise we'll continue looking.
24773 
24774   # Test: Is bootjdk explicitely set by command line arguments?
24775 
24776   if test "x$BOOT_JDK_FOUND" = xno; then
24777     # Now execute the test
24778 
24779   if test "x$with_boot_jdk" != x; then
24780     BOOT_JDK=$with_boot_jdk
24781     BOOT_JDK_FOUND=maybe
24782     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using configure arguments" >&5
24783 $as_echo "$as_me: Found potential Boot JDK using configure arguments" >&6;}
24784   fi
24785 
24786 
24787     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24788     if test "x$BOOT_JDK_FOUND" = xmaybe; then
24789       # Do we have a bin/java?
24790       if test ! -x "$BOOT_JDK/bin/java"; then
24791         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24792 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24793         BOOT_JDK_FOUND=no
24794       else
24795         # Do we have a bin/javac?
24796         if test ! -x "$BOOT_JDK/bin/javac"; then
24797           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24798 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24799           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24800 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24801           BOOT_JDK_FOUND=no
24802         else
24803           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24804           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
24805 
24806           # Extra M4 quote needed to protect [] in grep expression.
24807           FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
24808           if test "x$FOUND_CORRECT_VERSION" = x; then
24809             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24810 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24811             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
24812 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
24813             BOOT_JDK_FOUND=no
24814           else
24815             # We're done! :-)
24816             BOOT_JDK_FOUND=yes
24817 
24818   # Only process if variable expands to non-empty
24819 
24820   if test "x$BOOT_JDK" != x; then
24821     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24822 
24823   # Input might be given as Windows format, start by converting to
24824   # unix format.
24825   path="$BOOT_JDK"
24826   new_path=`$CYGPATH -u "$path"`
24827 
24828   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24829   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24830   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24831   # "foo.exe" is OK but "foo" is an error.
24832   #
24833   # This test is therefore slightly more accurate than "test -f" to check for file precense.
24834   # It is also a way to make sure we got the proper file name for the real test later on.
24835   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24836   if test "x$test_shortpath" = x; then
24837     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24838 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24839     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24840   fi
24841 
24842   # Call helper function which possibly converts this using DOS-style short mode.
24843   # If so, the updated path is stored in $new_path.
24844 
24845   input_path="$new_path"
24846   # Check if we need to convert this using DOS-style short mode. If the path
24847   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24848   # take no chances and rewrite it.
24849   # Note: m4 eats our [], so we need to use [ and ] instead.
24850   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24851   if test "x$has_forbidden_chars" != x; then
24852     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24853     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24854     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24855     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24856       # Going to short mode and back again did indeed matter. Since short mode is
24857       # case insensitive, let's make it lowercase to improve readability.
24858       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24859       # Now convert it back to Unix-style (cygpath)
24860       input_path=`$CYGPATH -u "$shortmode_path"`
24861       new_path="$input_path"
24862     fi
24863   fi
24864 
24865   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24866   if test "x$test_cygdrive_prefix" = x; then
24867     # As a simple fix, exclude /usr/bin since it's not a real path.
24868     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24869       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24870       # a path prefixed by /cygdrive for fixpath to work.
24871       new_path="$CYGWIN_ROOT_PATH$input_path"
24872     fi
24873   fi
24874 
24875 
24876   if test "x$path" != "x$new_path"; then
24877     BOOT_JDK="$new_path"
24878     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24879 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24880   fi
24881 
24882     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24883 
24884   path="$BOOT_JDK"
24885   has_colon=`$ECHO $path | $GREP ^.:`
24886   new_path="$path"
24887   if test "x$has_colon" = x; then
24888     # Not in mixed or Windows style, start by that.
24889     new_path=`cmd //c echo $path`
24890   fi
24891 
24892 
24893   input_path="$new_path"
24894   # Check if we need to convert this using DOS-style short mode. If the path
24895   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24896   # take no chances and rewrite it.
24897   # Note: m4 eats our [], so we need to use [ and ] instead.
24898   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24899   if test "x$has_forbidden_chars" != x; then
24900     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24901     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24902   fi
24903 
24904 
24905   windows_path="$new_path"
24906   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24907     unix_path=`$CYGPATH -u "$windows_path"`
24908     new_path="$unix_path"
24909   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24910     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24911     new_path="$unix_path"
24912   fi
24913 
24914   if test "x$path" != "x$new_path"; then
24915     BOOT_JDK="$new_path"
24916     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24917 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24918   fi
24919 
24920   # Save the first 10 bytes of this path to the storage, so fixpath can work.
24921   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24922 
24923     else
24924       # We're on a unix platform. Hooray! :)
24925       path="$BOOT_JDK"
24926       has_space=`$ECHO "$path" | $GREP " "`
24927       if test "x$has_space" != x; then
24928         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24929 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24930         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24931       fi
24932 
24933       # Use eval to expand a potential ~
24934       eval path="$path"
24935       if test ! -f "$path" && test ! -d "$path"; then
24936         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24937       fi
24938 
24939       if test -d "$path"; then
24940         BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24941       else
24942         dir="`$DIRNAME "$path"`"
24943         base="`$BASENAME "$path"`"
24944         BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
24945       fi
24946     fi
24947   fi
24948 
24949             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24950 $as_echo_n "checking for Boot JDK... " >&6; }
24951             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24952 $as_echo "$BOOT_JDK" >&6; }
24953             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24954 $as_echo_n "checking Boot JDK version... " >&6; }
24955             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
24956             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24957 $as_echo "$BOOT_JDK_VERSION" >&6; }
24958           fi # end check jdk version
24959         fi # end check javac
24960       fi # end check java
24961     fi # end check boot jdk found
24962   fi
24963 
24964   if test "x$with_boot_jdk" != x && test "x$BOOT_JDK_FOUND" = xno; then
24965     # Having specified an argument which is incorrect will produce an instant failure;
24966     # we should not go on looking
24967     as_fn_error $? "The path given by --with-boot-jdk does not contain a valid Boot JDK" "$LINENO" 5
24968   fi
24969 
24970   # Test: On MacOS X, can we find a boot jdk using /usr/libexec/java_home?
24971 
24972   if test "x$BOOT_JDK_FOUND" = xno; then
24973     # Now execute the test
24974 
24975   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
24976     # First check at user selected default
24977 
24978   if test "x$BOOT_JDK_FOUND" = xno; then
24979     # Now execute the test
24980 
24981   if test -x /usr/libexec/java_home; then
24982     BOOT_JDK=`/usr/libexec/java_home `
24983     BOOT_JDK_FOUND=maybe
24984     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home " >&5
24985 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home " >&6;}
24986   fi
24987 
24988 
24989     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24990     if test "x$BOOT_JDK_FOUND" = xmaybe; then
24991       # Do we have a bin/java?
24992       if test ! -x "$BOOT_JDK/bin/java"; then
24993         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24994 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24995         BOOT_JDK_FOUND=no
24996       else
24997         # Do we have a bin/javac?
24998         if test ! -x "$BOOT_JDK/bin/javac"; then
24999           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
25000 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
25001           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
25002 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
25003           BOOT_JDK_FOUND=no
25004         else
25005           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
25006           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
25007 
25008           # Extra M4 quote needed to protect [] in grep expression.
25009           FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
25010           if test "x$FOUND_CORRECT_VERSION" = x; then
25011             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
25012 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
25013             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
25014 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
25015             BOOT_JDK_FOUND=no
25016           else
25017             # We're done! :-)
25018             BOOT_JDK_FOUND=yes
25019 
25020   # Only process if variable expands to non-empty
25021 
25022   if test "x$BOOT_JDK" != x; then
25023     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
25024 
25025   # Input might be given as Windows format, start by converting to
25026   # unix format.
25027   path="$BOOT_JDK"
25028   new_path=`$CYGPATH -u "$path"`
25029 
25030   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
25031   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
25032   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
25033   # "foo.exe" is OK but "foo" is an error.
25034   #
25035   # This test is therefore slightly more accurate than "test -f" to check for file precense.
25036   # It is also a way to make sure we got the proper file name for the real test later on.
25037   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
25038   if test "x$test_shortpath" = x; then
25039     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
25040 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
25041     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
25042   fi
25043 
25044   # Call helper function which possibly converts this using DOS-style short mode.
25045   # If so, the updated path is stored in $new_path.
25046 
25047   input_path="$new_path"
25048   # Check if we need to convert this using DOS-style short mode. If the path
25049   # contains just simple characters, use it. Otherwise (spaces, weird characters),
25050   # take no chances and rewrite it.
25051   # Note: m4 eats our [], so we need to use [ and ] instead.
25052   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
25053   if test "x$has_forbidden_chars" != x; then
25054     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
25055     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
25056     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
25057     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
25058       # Going to short mode and back again did indeed matter. Since short mode is
25059       # case insensitive, let's make it lowercase to improve readability.
25060       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
25061       # Now convert it back to Unix-style (cygpath)
25062       input_path=`$CYGPATH -u "$shortmode_path"`
25063       new_path="$input_path"
25064     fi
25065   fi
25066 
25067   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
25068   if test "x$test_cygdrive_prefix" = x; then
25069     # As a simple fix, exclude /usr/bin since it's not a real path.
25070     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
25071       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
25072       # a path prefixed by /cygdrive for fixpath to work.
25073       new_path="$CYGWIN_ROOT_PATH$input_path"
25074     fi
25075   fi
25076 
25077 
25078   if test "x$path" != "x$new_path"; then
25079     BOOT_JDK="$new_path"
25080     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
25081 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
25082   fi
25083 
25084     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
25085 
25086   path="$BOOT_JDK"
25087   has_colon=`$ECHO $path | $GREP ^.:`
25088   new_path="$path"
25089   if test "x$has_colon" = x; then
25090     # Not in mixed or Windows style, start by that.
25091     new_path=`cmd //c echo $path`
25092   fi
25093 
25094 
25095   input_path="$new_path"
25096   # Check if we need to convert this using DOS-style short mode. If the path
25097   # contains just simple characters, use it. Otherwise (spaces, weird characters),
25098   # take no chances and rewrite it.
25099   # Note: m4 eats our [], so we need to use [ and ] instead.
25100   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
25101   if test "x$has_forbidden_chars" != x; then
25102     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
25103     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
25104   fi
25105 
25106 
25107   windows_path="$new_path"
25108   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
25109     unix_path=`$CYGPATH -u "$windows_path"`
25110     new_path="$unix_path"
25111   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
25112     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
25113     new_path="$unix_path"
25114   fi
25115 
25116   if test "x$path" != "x$new_path"; then
25117     BOOT_JDK="$new_path"
25118     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
25119 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
25120   fi
25121 
25122   # Save the first 10 bytes of this path to the storage, so fixpath can work.
25123   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
25124 
25125     else
25126       # We're on a unix platform. Hooray! :)
25127       path="$BOOT_JDK"
25128       has_space=`$ECHO "$path" | $GREP " "`
25129       if test "x$has_space" != x; then
25130         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
25131 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
25132         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
25133       fi
25134 
25135       # Use eval to expand a potential ~
25136       eval path="$path"
25137       if test ! -f "$path" && test ! -d "$path"; then
25138         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
25139       fi
25140 
25141       if test -d "$path"; then
25142         BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
25143       else
25144         dir="`$DIRNAME "$path"`"
25145         base="`$BASENAME "$path"`"
25146         BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
25147       fi
25148     fi
25149   fi
25150 
25151             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
25152 $as_echo_n "checking for Boot JDK... " >&6; }
25153             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
25154 $as_echo "$BOOT_JDK" >&6; }
25155             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
25156 $as_echo_n "checking Boot JDK version... " >&6; }
25157             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
25158             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
25159 $as_echo "$BOOT_JDK_VERSION" >&6; }
25160           fi # end check jdk version
25161         fi # end check javac
25162       fi # end check java
25163     fi # end check boot jdk found
25164   fi
25165 
25166     # If that did not work out (e.g. too old), try explicit versions instead
25167 
25168   if test "x$BOOT_JDK_FOUND" = xno; then
25169     # Now execute the test
25170 
25171   if test -x /usr/libexec/java_home; then
25172     BOOT_JDK=`/usr/libexec/java_home -v 1.9`
25173     BOOT_JDK_FOUND=maybe
25174     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home -v 1.9" >&5
25175 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home -v 1.9" >&6;}
25176   fi
25177 
25178 
25179     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
25180     if test "x$BOOT_JDK_FOUND" = xmaybe; then
25181       # Do we have a bin/java?
25182       if test ! -x "$BOOT_JDK/bin/java"; then
25183         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
25184 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
25185         BOOT_JDK_FOUND=no
25186       else
25187         # Do we have a bin/javac?
25188         if test ! -x "$BOOT_JDK/bin/javac"; then
25189           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
25190 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
25191           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
25192 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
25193           BOOT_JDK_FOUND=no
25194         else
25195           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
25196           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
25197 
25198           # Extra M4 quote needed to protect [] in grep expression.
25199           FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
25200           if test "x$FOUND_CORRECT_VERSION" = x; then
25201             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
25202 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
25203             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
25204 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
25205             BOOT_JDK_FOUND=no
25206           else
25207             # We're done! :-)
25208             BOOT_JDK_FOUND=yes
25209 
25210   # Only process if variable expands to non-empty
25211 
25212   if test "x$BOOT_JDK" != x; then
25213     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
25214 
25215   # Input might be given as Windows format, start by converting to
25216   # unix format.
25217   path="$BOOT_JDK"
25218   new_path=`$CYGPATH -u "$path"`
25219 
25220   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
25221   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
25222   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
25223   # "foo.exe" is OK but "foo" is an error.
25224   #
25225   # This test is therefore slightly more accurate than "test -f" to check for file precense.
25226   # It is also a way to make sure we got the proper file name for the real test later on.
25227   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
25228   if test "x$test_shortpath" = x; then
25229     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
25230 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
25231     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
25232   fi
25233 
25234   # Call helper function which possibly converts this using DOS-style short mode.
25235   # If so, the updated path is stored in $new_path.
25236 
25237   input_path="$new_path"
25238   # Check if we need to convert this using DOS-style short mode. If the path
25239   # contains just simple characters, use it. Otherwise (spaces, weird characters),
25240   # take no chances and rewrite it.
25241   # Note: m4 eats our [], so we need to use [ and ] instead.
25242   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
25243   if test "x$has_forbidden_chars" != x; then
25244     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
25245     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
25246     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
25247     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
25248       # Going to short mode and back again did indeed matter. Since short mode is
25249       # case insensitive, let's make it lowercase to improve readability.
25250       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
25251       # Now convert it back to Unix-style (cygpath)
25252       input_path=`$CYGPATH -u "$shortmode_path"`
25253       new_path="$input_path"
25254     fi
25255   fi
25256 
25257   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
25258   if test "x$test_cygdrive_prefix" = x; then
25259     # As a simple fix, exclude /usr/bin since it's not a real path.
25260     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
25261       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
25262       # a path prefixed by /cygdrive for fixpath to work.
25263       new_path="$CYGWIN_ROOT_PATH$input_path"
25264     fi
25265   fi
25266 
25267 
25268   if test "x$path" != "x$new_path"; then
25269     BOOT_JDK="$new_path"
25270     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
25271 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
25272   fi
25273 
25274     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
25275 
25276   path="$BOOT_JDK"
25277   has_colon=`$ECHO $path | $GREP ^.:`
25278   new_path="$path"
25279   if test "x$has_colon" = x; then
25280     # Not in mixed or Windows style, start by that.
25281     new_path=`cmd //c echo $path`
25282   fi
25283 
25284 
25285   input_path="$new_path"
25286   # Check if we need to convert this using DOS-style short mode. If the path
25287   # contains just simple characters, use it. Otherwise (spaces, weird characters),
25288   # take no chances and rewrite it.
25289   # Note: m4 eats our [], so we need to use [ and ] instead.
25290   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
25291   if test "x$has_forbidden_chars" != x; then
25292     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
25293     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
25294   fi
25295 
25296 
25297   windows_path="$new_path"
25298   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
25299     unix_path=`$CYGPATH -u "$windows_path"`
25300     new_path="$unix_path"
25301   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
25302     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
25303     new_path="$unix_path"
25304   fi
25305 
25306   if test "x$path" != "x$new_path"; then
25307     BOOT_JDK="$new_path"
25308     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
25309 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
25310   fi
25311 
25312   # Save the first 10 bytes of this path to the storage, so fixpath can work.
25313   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
25314 
25315     else
25316       # We're on a unix platform. Hooray! :)
25317       path="$BOOT_JDK"
25318       has_space=`$ECHO "$path" | $GREP " "`
25319       if test "x$has_space" != x; then
25320         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
25321 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
25322         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
25323       fi
25324 
25325       # Use eval to expand a potential ~
25326       eval path="$path"
25327       if test ! -f "$path" && test ! -d "$path"; then
25328         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
25329       fi
25330 
25331       if test -d "$path"; then
25332         BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
25333       else
25334         dir="`$DIRNAME "$path"`"
25335         base="`$BASENAME "$path"`"
25336         BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
25337       fi
25338     fi
25339   fi
25340 
25341             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
25342 $as_echo_n "checking for Boot JDK... " >&6; }
25343             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
25344 $as_echo "$BOOT_JDK" >&6; }
25345             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
25346 $as_echo_n "checking Boot JDK version... " >&6; }
25347             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
25348             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
25349 $as_echo "$BOOT_JDK_VERSION" >&6; }
25350           fi # end check jdk version
25351         fi # end check javac
25352       fi # end check java
25353     fi # end check boot jdk found
25354   fi
25355 
25356 
25357   if test "x$BOOT_JDK_FOUND" = xno; then
25358     # Now execute the test
25359 
25360   if test -x /usr/libexec/java_home; then
25361     BOOT_JDK=`/usr/libexec/java_home -v 1.8`
25362     BOOT_JDK_FOUND=maybe
25363     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home -v 1.8" >&5
25364 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home -v 1.8" >&6;}
25365   fi
25366 
25367 
25368     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
25369     if test "x$BOOT_JDK_FOUND" = xmaybe; then
25370       # Do we have a bin/java?
25371       if test ! -x "$BOOT_JDK/bin/java"; then
25372         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
25373 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
25374         BOOT_JDK_FOUND=no
25375       else
25376         # Do we have a bin/javac?
25377         if test ! -x "$BOOT_JDK/bin/javac"; then
25378           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; i