1 #!/bin/bash
   2 #
   3 # ##########################################################
   4 # ### THIS FILE IS AUTOMATICALLY GENERATED. DO NOT EDIT. ###
   5 # ##########################################################
   6 #
   7 #! /bin/sh
   8 # Guess values for system-dependent variables and create Makefiles.
   9 # Generated by GNU Autoconf 2.69 for OpenJDK jdk9.
  10 #
  11 # Report bugs to <build-dev@openjdk.java.net>.
  12 #
  13 #
  14 # Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
  15 #
  16 #
  17 # This configure script is free software; the Free Software Foundation
  18 # gives unlimited permission to copy, distribute and modify it.
  19 ## -------------------- ##
  20 ## M4sh Initialization. ##
  21 ## -------------------- ##
  22 
  23 # Be more Bourne compatible
  24 DUALCASE=1; export DUALCASE # for MKS sh
  25 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
  26   emulate sh
  27   NULLCMD=:
  28   # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
  29   # is contrary to our usage.  Disable this feature.
  30   alias -g '${1+"$@"}'='"$@"'
  31   setopt NO_GLOB_SUBST
  32 else
  33   case `(set -o) 2>/dev/null` in #(
  34   *posix*) :
  35     set -o posix ;; #(
  36   *) :
  37      ;;
  38 esac
  39 fi
  40 
  41 
  42 as_nl='
  43 '
  44 export as_nl
  45 # Printing a long string crashes Solaris 7 /usr/bin/printf.
  46 as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
  47 as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
  48 as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
  49 # Prefer a ksh shell builtin over an external printf program on Solaris,
  50 # but without wasting forks for bash or zsh.
  51 if test -z "$BASH_VERSION$ZSH_VERSION" \
  52     && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
  53   as_echo='print -r --'
  54   as_echo_n='print -rn --'
  55 elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
  56   as_echo='printf %s\n'
  57   as_echo_n='printf %s'
  58 else
  59   if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
  60     as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
  61     as_echo_n='/usr/ucb/echo -n'
  62   else
  63     as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
  64     as_echo_n_body='eval
  65       arg=$1;
  66       case $arg in #(
  67       *"$as_nl"*)
  68         expr "X$arg" : "X\\(.*\\)$as_nl";
  69         arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
  70       esac;
  71       expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
  72     '
  73     export as_echo_n_body
  74     as_echo_n='sh -c $as_echo_n_body as_echo'
  75   fi
  76   export as_echo_body
  77   as_echo='sh -c $as_echo_body as_echo'
  78 fi
  79 
  80 # The user is always right.
  81 if test "${PATH_SEPARATOR+set}" != set; then
  82   PATH_SEPARATOR=:
  83   (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
  84     (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
  85       PATH_SEPARATOR=';'
  86   }
  87 fi
  88 
  89 
  90 # IFS
  91 # We need space, tab and new line, in precisely that order.  Quoting is
  92 # there to prevent editors from complaining about space-tab.
  93 # (If _AS_PATH_WALK were called with IFS unset, it would disable word
  94 # splitting by setting IFS to empty value.)
  95 IFS=" ""        $as_nl"
  96 
  97 # Find who we are.  Look in the path if we contain no directory separator.
  98 as_myself=
  99 case $0 in #((
 100   *[\\/]* ) as_myself=$0 ;;
 101   *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 102 for as_dir in $PATH
 103 do
 104   IFS=$as_save_IFS
 105   test -z "$as_dir" && as_dir=.
 106     test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
 107   done
 108 IFS=$as_save_IFS
 109 
 110      ;;
 111 esac
 112 # We did not find ourselves, most probably we were run as `sh COMMAND'
 113 # in which case we are not to be found in the path.
 114 if test "x$as_myself" = x; then
 115   as_myself=$0
 116 fi
 117 if test ! -f "$as_myself"; then
 118   $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
 119   exit 1
 120 fi
 121 
 122 # Unset variables that we do not need and which cause bugs (e.g. in
 123 # pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
 124 # suppresses any "Segmentation fault" message there.  '((' could
 125 # trigger a bug in pdksh 5.2.14.
 126 for as_var in BASH_ENV ENV MAIL MAILPATH
 127 do eval test x\${$as_var+set} = xset \
 128   && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
 129 done
 130 PS1='$ '
 131 PS2='> '
 132 PS4='+ '
 133 
 134 # NLS nuisances.
 135 LC_ALL=C
 136 export LC_ALL
 137 LANGUAGE=C
 138 export LANGUAGE
 139 
 140 # CDPATH.
 141 (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
 142 
 143 # Use a proper internal environment variable to ensure we don't fall
 144   # into an infinite loop, continuously re-executing ourselves.
 145   if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then
 146     _as_can_reexec=no; export _as_can_reexec;
 147     # We cannot yet assume a decent shell, so we have to provide a
 148 # neutralization value for shells without unset; and this also
 149 # works around shells that cannot unset nonexistent variables.
 150 # Preserve -v and -x to the replacement shell.
 151 BASH_ENV=/dev/null
 152 ENV=/dev/null
 153 (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
 154 case $- in # ((((
 155   *v*x* | *x*v* ) as_opts=-vx ;;
 156   *v* ) as_opts=-v ;;
 157   *x* ) as_opts=-x ;;
 158   * ) as_opts= ;;
 159 esac
 160 exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
 161 # Admittedly, this is quite paranoid, since all the known shells bail
 162 # out after a failed `exec'.
 163 $as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
 164 as_fn_exit 255
 165   fi
 166   # We don't want this to propagate to other subprocesses.
 167           { _as_can_reexec=; unset _as_can_reexec;}
 168 if test "x$CONFIG_SHELL" = x; then
 169   as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then :
 170   emulate sh
 171   NULLCMD=:
 172   # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which
 173   # is contrary to our usage.  Disable this feature.
 174   alias -g '\${1+\"\$@\"}'='\"\$@\"'
 175   setopt NO_GLOB_SUBST
 176 else
 177   case \`(set -o) 2>/dev/null\` in #(
 178   *posix*) :
 179     set -o posix ;; #(
 180   *) :
 181      ;;
 182 esac
 183 fi
 184 "
 185   as_required="as_fn_return () { (exit \$1); }
 186 as_fn_success () { as_fn_return 0; }
 187 as_fn_failure () { as_fn_return 1; }
 188 as_fn_ret_success () { return 0; }
 189 as_fn_ret_failure () { return 1; }
 190 
 191 exitcode=0
 192 as_fn_success || { exitcode=1; echo as_fn_success failed.; }
 193 as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; }
 194 as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; }
 195 as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; }
 196 if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then :
 197 
 198 else
 199   exitcode=1; echo positional parameters were not saved.
 200 fi
 201 test x\$exitcode = x0 || exit 1
 202 test -x / || exit 1"
 203   as_suggested="  as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO
 204   as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO
 205   eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" &&
 206   test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1
 207 test \$(( 1 + 1 )) = 2 || exit 1"
 208   if (eval "$as_required") 2>/dev/null; then :
 209   as_have_required=yes
 210 else
 211   as_have_required=no
 212 fi
 213   if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then :
 214 
 215 else
 216   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 217 as_found=false
 218 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
 219 do
 220   IFS=$as_save_IFS
 221   test -z "$as_dir" && as_dir=.
 222   as_found=:
 223   case $as_dir in #(
 224          /*)
 225            for as_base in sh bash ksh sh5; do
 226              # Try only shells that exist, to save several forks.
 227              as_shell=$as_dir/$as_base
 228              if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
 229                     { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then :
 230   CONFIG_SHELL=$as_shell as_have_required=yes
 231                    if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then :
 232   break 2
 233 fi
 234 fi
 235            done;;
 236        esac
 237   as_found=false
 238 done
 239 $as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } &&
 240               { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then :
 241   CONFIG_SHELL=$SHELL as_have_required=yes
 242 fi; }
 243 IFS=$as_save_IFS
 244 
 245 
 246       if test "x$CONFIG_SHELL" != x; then :
 247   export CONFIG_SHELL
 248              # We cannot yet assume a decent shell, so we have to provide a
 249 # neutralization value for shells without unset; and this also
 250 # works around shells that cannot unset nonexistent variables.
 251 # Preserve -v and -x to the replacement shell.
 252 BASH_ENV=/dev/null
 253 ENV=/dev/null
 254 (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
 255 case $- in # ((((
 256   *v*x* | *x*v* ) as_opts=-vx ;;
 257   *v* ) as_opts=-v ;;
 258   *x* ) as_opts=-x ;;
 259   * ) as_opts= ;;
 260 esac
 261 exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
 262 # Admittedly, this is quite paranoid, since all the known shells bail
 263 # out after a failed `exec'.
 264 $as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
 265 exit 255
 266 fi
 267 
 268     if test x$as_have_required = xno; then :
 269   $as_echo "$0: This script requires a shell more modern than all"
 270   $as_echo "$0: the shells that I found on your system."
 271   if test x${ZSH_VERSION+set} = xset ; then
 272     $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should"
 273     $as_echo "$0: be upgraded to zsh 4.3.4 or later."
 274   else
 275     $as_echo "$0: Please tell bug-autoconf@gnu.org and
 276 $0: build-dev@openjdk.java.net about your system, including
 277 $0: any error possibly output before this message. Then
 278 $0: install a modern shell, or manually run the script
 279 $0: under such a shell if you do have one."
 280   fi
 281   exit 1
 282 fi
 283 fi
 284 fi
 285 SHELL=${CONFIG_SHELL-/bin/sh}
 286 export SHELL
 287 # Unset more variables known to interfere with behavior of common tools.
 288 CLICOLOR_FORCE= GREP_OPTIONS=
 289 unset CLICOLOR_FORCE GREP_OPTIONS
 290 
 291 ## --------------------- ##
 292 ## M4sh Shell Functions. ##
 293 ## --------------------- ##
 294 # as_fn_unset VAR
 295 # ---------------
 296 # Portably unset VAR.
 297 as_fn_unset ()
 298 {
 299   { eval $1=; unset $1;}
 300 }
 301 as_unset=as_fn_unset
 302 
 303 # as_fn_set_status STATUS
 304 # -----------------------
 305 # Set $? to STATUS, without forking.
 306 as_fn_set_status ()
 307 {
 308   return $1
 309 } # as_fn_set_status
 310 
 311 # as_fn_exit STATUS
 312 # -----------------
 313 # Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
 314 as_fn_exit ()
 315 {
 316   set +e
 317   as_fn_set_status $1
 318   exit $1
 319 } # as_fn_exit
 320 
 321 # as_fn_mkdir_p
 322 # -------------
 323 # Create "$as_dir" as a directory, including parents if necessary.
 324 as_fn_mkdir_p ()
 325 {
 326 
 327   case $as_dir in #(
 328   -*) as_dir=./$as_dir;;
 329   esac
 330   test -d "$as_dir" || eval $as_mkdir_p || {
 331     as_dirs=
 332     while :; do
 333       case $as_dir in #(
 334       *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
 335       *) as_qdir=$as_dir;;
 336       esac
 337       as_dirs="'$as_qdir' $as_dirs"
 338       as_dir=`$as_dirname -- "$as_dir" ||
 339 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 340          X"$as_dir" : 'X\(//\)[^/]' \| \
 341          X"$as_dir" : 'X\(//\)$' \| \
 342          X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
 343 $as_echo X"$as_dir" |
 344     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
 345             s//\1/
 346             q
 347           }
 348           /^X\(\/\/\)[^/].*/{
 349             s//\1/
 350             q
 351           }
 352           /^X\(\/\/\)$/{
 353             s//\1/
 354             q
 355           }
 356           /^X\(\/\).*/{
 357             s//\1/
 358             q
 359           }
 360           s/.*/./; q'`
 361       test -d "$as_dir" && break
 362     done
 363     test -z "$as_dirs" || eval "mkdir $as_dirs"
 364   } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
 365 
 366 
 367 } # as_fn_mkdir_p
 368 
 369 # as_fn_executable_p FILE
 370 # -----------------------
 371 # Test if FILE is an executable regular file.
 372 as_fn_executable_p ()
 373 {
 374   test -f "$1" && test -x "$1"
 375 } # as_fn_executable_p
 376 # as_fn_append VAR VALUE
 377 # ----------------------
 378 # Append the text in VALUE to the end of the definition contained in VAR. Take
 379 # advantage of any shell optimizations that allow amortized linear growth over
 380 # repeated appends, instead of the typical quadratic growth present in naive
 381 # implementations.
 382 if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
 383   eval 'as_fn_append ()
 384   {
 385     eval $1+=\$2
 386   }'
 387 else
 388   as_fn_append ()
 389   {
 390     eval $1=\$$1\$2
 391   }
 392 fi # as_fn_append
 393 
 394 # as_fn_arith ARG...
 395 # ------------------
 396 # Perform arithmetic evaluation on the ARGs, and store the result in the
 397 # global $as_val. Take advantage of shells that can avoid forks. The arguments
 398 # must be portable across $(()) and expr.
 399 if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
 400   eval 'as_fn_arith ()
 401   {
 402     as_val=$(( $* ))
 403   }'
 404 else
 405   as_fn_arith ()
 406   {
 407     as_val=`expr "$@" || test $? -eq 1`
 408   }
 409 fi # as_fn_arith
 410 
 411 
 412 # as_fn_error STATUS ERROR [LINENO LOG_FD]
 413 # ----------------------------------------
 414 # Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
 415 # provided, also output the error to LOG_FD, referencing LINENO. Then exit the
 416 # script with STATUS, using 1 if that was 0.
 417 as_fn_error ()
 418 {
 419   as_status=$1; test $as_status -eq 0 && as_status=1
 420   if test "$4"; then
 421     as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
 422     $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
 423   fi
 424   $as_echo "$as_me: error: $2" >&2
 425   as_fn_exit $as_status
 426 } # as_fn_error
 427 
 428 if expr a : '\(a\)' >/dev/null 2>&1 &&
 429    test "X`expr 00001 : '.*\(...\)'`" = X001; then
 430   as_expr=expr
 431 else
 432   as_expr=false
 433 fi
 434 
 435 if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
 436   as_basename=basename
 437 else
 438   as_basename=false
 439 fi
 440 
 441 if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
 442   as_dirname=dirname
 443 else
 444   as_dirname=false
 445 fi
 446 
 447 as_me=`$as_basename -- "$0" ||
 448 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
 449          X"$0" : 'X\(//\)$' \| \
 450          X"$0" : 'X\(/\)' \| . 2>/dev/null ||
 451 $as_echo X/"$0" |
 452     sed '/^.*\/\([^/][^/]*\)\/*$/{
 453             s//\1/
 454             q
 455           }
 456           /^X\/\(\/\/\)$/{
 457             s//\1/
 458             q
 459           }
 460           /^X\/\(\/\).*/{
 461             s//\1/
 462             q
 463           }
 464           s/.*/./; q'`
 465 
 466 # Avoid depending upon Character Ranges.
 467 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
 468 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
 469 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
 470 as_cr_digits='0123456789'
 471 as_cr_alnum=$as_cr_Letters$as_cr_digits
 472 
 473 
 474   as_lineno_1=$LINENO as_lineno_1a=$LINENO
 475   as_lineno_2=$LINENO as_lineno_2a=$LINENO
 476   eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" &&
 477   test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || {
 478   # Blame Lee E. McMahon (1931-1989) for sed's syntax.  :-)
 479   sed -n '
 480     p
 481     /[$]LINENO/=
 482   ' <$as_myself |
 483     sed '
 484       s/[$]LINENO.*/&-/
 485       t lineno
 486       b
 487       :lineno
 488       N
 489       :loop
 490       s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
 491       t loop
 492       s/-\n.*//
 493     ' >$as_me.lineno &&
 494   chmod +x "$as_me.lineno" ||
 495     { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }
 496 
 497   # If we had to re-execute with $CONFIG_SHELL, we're ensured to have
 498   # already done that, so ensure we don't try to do so again and fall
 499   # in an infinite loop.  This has already happened in practice.
 500   _as_can_reexec=no; export _as_can_reexec
 501   # Don't try to exec as it changes $[0], causing all sort of problems
 502   # (the dirname of $[0] is not the place where we might find the
 503   # original and so on.  Autoconf is especially sensitive to this).
 504   . "./$as_me.lineno"
 505   # Exit status is that of the last command.
 506   exit
 507 }
 508 
 509 ECHO_C= ECHO_N= ECHO_T=
 510 case `echo -n x` in #(((((
 511 -n*)
 512   case `echo 'xy\c'` in
 513   *c*) ECHO_T=' ';;     # ECHO_T is single tab character.
 514   xy)  ECHO_C='\c';;
 515   *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
 516        ECHO_T=' ';;
 517   esac;;
 518 *)
 519   ECHO_N='-n';;
 520 esac
 521 
 522 rm -f conf$$ conf$$.exe conf$$.file
 523 if test -d conf$$.dir; then
 524   rm -f conf$$.dir/conf$$.file
 525 else
 526   rm -f conf$$.dir
 527   mkdir conf$$.dir 2>/dev/null
 528 fi
 529 if (echo >conf$$.file) 2>/dev/null; then
 530   if ln -s conf$$.file conf$$ 2>/dev/null; then
 531     as_ln_s='ln -s'
 532     # ... but there are two gotchas:
 533     # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
 534     # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
 535     # In both cases, we have to default to `cp -pR'.
 536     ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
 537       as_ln_s='cp -pR'
 538   elif ln conf$$.file conf$$ 2>/dev/null; then
 539     as_ln_s=ln
 540   else
 541     as_ln_s='cp -pR'
 542   fi
 543 else
 544   as_ln_s='cp -pR'
 545 fi
 546 rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
 547 rmdir conf$$.dir 2>/dev/null
 548 
 549 if mkdir -p . 2>/dev/null; then
 550   as_mkdir_p='mkdir -p "$as_dir"'
 551 else
 552   test -d ./-p && rmdir ./-p
 553   as_mkdir_p=false
 554 fi
 555 
 556 as_test_x='test -x'
 557 as_executable_p=as_fn_executable_p
 558 
 559 # Sed expression to map a string onto a valid CPP name.
 560 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
 561 
 562 # Sed expression to map a string onto a valid variable name.
 563 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
 564 
 565 
 566 test -n "$DJDIR" || exec 7<&0 </dev/null
 567 exec 6>&1
 568 
 569 # Name of the host.
 570 # hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status,
 571 # so uname gets run too.
 572 ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
 573 
 574 #
 575 # Initializations.
 576 #
 577 ac_default_prefix=/usr/local
 578 ac_clean_files=
 579 ac_config_libobj_dir=.
 580 LIBOBJS=
 581 cross_compiling=no
 582 subdirs=
 583 MFLAGS=
 584 MAKEFLAGS=
 585 
 586 # Identity of this package.
 587 PACKAGE_NAME='OpenJDK'
 588 PACKAGE_TARNAME='openjdk'
 589 PACKAGE_VERSION='jdk9'
 590 PACKAGE_STRING='OpenJDK jdk9'
 591 PACKAGE_BUGREPORT='build-dev@openjdk.java.net'
 592 PACKAGE_URL='http://openjdk.java.net'
 593 
 594 # Factoring default headers for most tests.
 595 ac_includes_default="\
 596 #include <stdio.h>
 597 #ifdef HAVE_SYS_TYPES_H
 598 # include <sys/types.h>
 599 #endif
 600 #ifdef HAVE_SYS_STAT_H
 601 # include <sys/stat.h>
 602 #endif
 603 #ifdef STDC_HEADERS
 604 # include <stdlib.h>
 605 # include <stddef.h>
 606 #else
 607 # ifdef HAVE_STDLIB_H
 608 #  include <stdlib.h>
 609 # endif
 610 #endif
 611 #ifdef HAVE_STRING_H
 612 # if !defined STDC_HEADERS && defined HAVE_MEMORY_H
 613 #  include <memory.h>
 614 # endif
 615 # include <string.h>
 616 #endif
 617 #ifdef HAVE_STRINGS_H
 618 # include <strings.h>
 619 #endif
 620 #ifdef HAVE_INTTYPES_H
 621 # include <inttypes.h>
 622 #endif
 623 #ifdef HAVE_STDINT_H
 624 # include <stdint.h>
 625 #endif
 626 #ifdef HAVE_UNISTD_H
 627 # include <unistd.h>
 628 #endif"
 629 
 630 ac_subst_vars='LTLIBOBJS
 631 LIBOBJS
 632 CFLAGS_CCACHE
 633 CCACHE
 634 USE_PRECOMPILED_HEADER
 635 BUILD_ICECC
 636 ICECC
 637 ICECC_WRAPPER
 638 ICECC_CREATE_ENV
 639 ICECC_CMD
 640 ENABLE_JAVAC_SERVER
 641 ENABLE_SJAVAC
 642 SJAVAC_SERVER_JAVA_FLAGS
 643 SJAVAC_SERVER_JAVA
 644 JAVA_TOOL_FLAGS_SMALL
 645 JAVA_FLAGS_SMALL
 646 JAVA_FLAGS_JAVAC
 647 JAVA_FLAGS_BIG
 648 JAVA_FLAGS
 649 TEST_JOBS
 650 JOBS
 651 MEMORY_SIZE
 652 NUM_CORES
 653 BUILD_FAILURE_HANDLER
 654 ENABLE_INTREE_EC
 655 JVM_VARIANT_CORE
 656 JVM_VARIANT_ZEROSHARK
 657 JVM_VARIANT_ZERO
 658 JVM_VARIANT_HOTSPOT
 659 JVM_VARIANT_MINIMAL1
 660 JVM_VARIANT_CLIENT
 661 JVM_VARIANT_SERVER
 662 JVM_VARIANTS_COMMA
 663 TEST_IN_BUILD
 664 HOTSPOT_MAKE_ARGS
 665 MACOSX_UNIVERSAL
 666 DEBUG_CLASSFILES
 667 FASTDEBUG
 668 VARIANT
 669 USE_NEW_HOTSPOT_BUILD
 670 LIBZIP_CAN_USE_MMAP
 671 LIBDL
 672 LIBM
 673 USE_EXTERNAL_LCMS
 674 LCMS_LIBS
 675 LCMS_CFLAGS
 676 USE_EXTERNAL_LIBZ
 677 USE_EXTERNAL_LIBPNG
 678 PNG_LIBS
 679 PNG_CFLAGS
 680 USE_EXTERNAL_LIBGIF
 681 USE_EXTERNAL_LIBJPEG
 682 LLVM_LIBS
 683 LLVM_LDFLAGS
 684 LLVM_CFLAGS
 685 LLVM_CONFIG
 686 LIBFFI_LIBS
 687 LIBFFI_CFLAGS
 688 ALSA_LIBS
 689 ALSA_CFLAGS
 690 FREETYPE_BUNDLE_LIB_PATH
 691 FREETYPE_LIBS
 692 FREETYPE_CFLAGS
 693 CUPS_CFLAGS
 694 X_EXTRA_LIBS
 695 X_LIBS
 696 X_PRE_LIBS
 697 X_CFLAGS
 698 XMKMF
 699 MSVCP_DLL
 700 MSVCR_DLL
 701 LIBCXX
 702 STATIC_CXX_SETTING
 703 FIXPATH_DETACH_FLAG
 704 FIXPATH
 705 VALID_JVM_FEATURES
 706 JVM_FEATURES_custom
 707 JVM_FEATURES_zeroshark
 708 JVM_FEATURES_zero
 709 JVM_FEATURES_minimal
 710 JVM_FEATURES_core
 711 JVM_FEATURES_client
 712 JVM_FEATURES_server
 713 INCLUDE_DTRACE
 714 GCOV_ENABLED
 715 STRIP_POLICY
 716 DEBUG_BINARIES
 717 ZIP_EXTERNAL_DEBUG_SYMBOLS
 718 COPY_DEBUG_SYMBOLS
 719 COMPILE_WITH_DEBUG_SYMBOLS
 720 CFLAGS_WARNINGS_ARE_ERRORS
 721 BUILD_CC_DISABLE_WARNING_PREFIX
 722 DISABLE_WARNING_PREFIX
 723 HOTSPOT_SET_WARNINGS_AS_ERRORS
 724 WARNINGS_AS_ERRORS
 725 COMPILER_SUPPORTS_TARGET_BITS_FLAG
 726 ZERO_ARCHFLAG
 727 LDFLAGS_TESTEXE
 728 LDFLAGS_TESTLIB
 729 CXXFLAGS_TESTEXE
 730 CXXFLAGS_TESTLIB
 731 CFLAGS_TESTEXE
 732 CFLAGS_TESTLIB
 733 OPENJDK_BUILD_JVM_LIBS
 734 OPENJDK_BUILD_JVM_ASFLAGS
 735 OPENJDK_BUILD_JVM_LDFLAGS
 736 OPENJDK_BUILD_JVM_CFLAGS
 737 OPENJDK_BUILD_LDFLAGS_HASH_STYLE
 738 OPENJDK_BUILD_LDFLAGS_CXX_JDK
 739 OPENJDK_BUILD_JDKEXE_LIBS
 740 OPENJDK_BUILD_JDKLIB_LIBS
 741 OPENJDK_BUILD_LDFLAGS_JDKEXE
 742 OPENJDK_BUILD_LDFLAGS_JDKLIB
 743 OPENJDK_BUILD_CXXFLAGS_JDKEXE
 744 OPENJDK_BUILD_CXXFLAGS_JDKLIB
 745 OPENJDK_BUILD_CFLAGS_JDKEXE
 746 OPENJDK_BUILD_CFLAGS_JDKLIB
 747 OPENJDK_BUILD_CXXSTD_CXXFLAG
 748 JVM_LIBS
 749 JVM_ASFLAGS
 750 JVM_LDFLAGS
 751 JVM_CFLAGS
 752 LDFLAGS_HASH_STYLE
 753 LDFLAGS_CXX_JDK
 754 JDKEXE_LIBS
 755 JDKLIB_LIBS
 756 LDFLAGS_JDKEXE
 757 LDFLAGS_JDKLIB
 758 CXXFLAGS_JDKEXE
 759 CXXFLAGS_JDKLIB
 760 CFLAGS_JDKEXE
 761 CFLAGS_JDKLIB
 762 MACOSX_VERSION_MIN
 763 NO_LIFETIME_DSE_CFLAG
 764 NO_NULL_POINTER_CHECK_CFLAG
 765 CXXSTD_CXXFLAG
 766 CXX_O_FLAG_SIZE
 767 CXX_O_FLAG_NONE
 768 CXX_O_FLAG_DEBUG
 769 CXX_O_FLAG_NORM
 770 CXX_O_FLAG_HI
 771 CXX_O_FLAG_HIGHEST
 772 CXX_O_FLAG_HIGHEST_JVM
 773 C_O_FLAG_SIZE
 774 C_O_FLAG_NONE
 775 C_O_FLAG_DEBUG
 776 C_O_FLAG_NORM
 777 C_O_FLAG_HI
 778 C_O_FLAG_HIGHEST
 779 C_O_FLAG_HIGHEST_JVM
 780 JVM_CFLAGS_SYMBOLS
 781 CXXFLAGS_DEBUG_SYMBOLS
 782 CFLAGS_DEBUG_SYMBOLS
 783 CXX_FLAG_DEPS
 784 C_FLAG_DEPS
 785 SHARED_LIBRARY_FLAGS
 786 SET_SHARED_LIBRARY_MAPFILE
 787 SET_SHARED_LIBRARY_NAME
 788 SET_SHARED_LIBRARY_ORIGIN
 789 SET_EXECUTABLE_ORIGIN
 790 CXX_FLAG_REORDER
 791 C_FLAG_REORDER
 792 JVM_RCFLAGS
 793 RC_FLAGS
 794 AR_OUT_OPTION
 795 LD_OUT_OPTION
 796 EXE_OUT_OPTION
 797 CC_OUT_OPTION
 798 STRIPFLAGS
 799 ARFLAGS
 800 COMPILER_BINDCMD_FILE_FLAG
 801 COMPILER_COMMAND_FILE_FLAG
 802 COMPILER_TARGET_BITS_FLAG
 803 JT_HOME
 804 JTREGEXE
 805 HOTSPOT_TOOLCHAIN_TYPE
 806 USING_BROKEN_SUSE_LD
 807 PACKAGE_PATH
 808 USE_CLANG
 809 HOTSPOT_LD
 810 HOTSPOT_CXX
 811 HOTSPOT_RC
 812 HOTSPOT_MT
 813 BUILD_AS
 814 BUILD_LDCXX
 815 BUILD_LD
 816 BUILD_STRIP
 817 BUILD_OBJCOPY
 818 BUILD_AR
 819 BUILD_NM
 820 BUILD_CXX
 821 BUILD_CC
 822 BUILD_SYSROOT_LDFLAGS
 823 BUILD_SYSROOT_CFLAGS
 824 ac_ct_OBJDUMP
 825 OBJDUMP
 826 ac_ct_OBJCOPY
 827 OBJCOPY
 828 ac_ct_NM
 829 ac_ct_STRIP
 830 GNM
 831 NM
 832 STRIP
 833 MSBUILD
 834 DUMPBIN
 835 RC
 836 MT
 837 LIPO
 838 ac_ct_AR
 839 AR
 840 AS
 841 LDCXX
 842 LD
 843 CXXCPP
 844 CPP
 845 CXX_VERSION_NUMBER
 846 CC_VERSION_NUMBER
 847 ac_ct_CXX
 848 CXXFLAGS
 849 CXX
 850 TOOLCHAIN_PATH_CXX
 851 POTENTIAL_CXX
 852 OBJEXT
 853 EXEEXT
 854 ac_ct_CC
 855 CPPFLAGS
 856 LDFLAGS
 857 CFLAGS
 858 CC
 859 TOOLCHAIN_PATH_CC
 860 POTENTIAL_CC
 861 TOOLCHAIN_VERSION
 862 VS_LIB
 863 VS_INCLUDE
 864 VS_PATH
 865 CYGWIN_LINK
 866 SYSROOT_LDFLAGS
 867 SYSROOT_CFLAGS
 868 EXTRA_LDFLAGS
 869 EXTRA_CXXFLAGS
 870 EXTRA_CFLAGS
 871 LEGACY_EXTRA_LDFLAGS
 872 LEGACY_EXTRA_CXXFLAGS
 873 LEGACY_EXTRA_CFLAGS
 874 EXE_SUFFIX
 875 OBJ_SUFFIX
 876 STATIC_LIBRARY
 877 SHARED_LIBRARY
 878 STATIC_LIBRARY_SUFFIX
 879 SHARED_LIBRARY_SUFFIX
 880 LIBRARY_PREFIX
 881 TOOLCHAIN_TYPE
 882 STATIC_BUILD
 883 IMPORT_MODULES_MAKE
 884 IMPORT_MODULES_SRC
 885 IMPORT_MODULES_CONF
 886 IMPORT_MODULES_LIBS
 887 IMPORT_MODULES_CMDS
 888 IMPORT_MODULES_CLASSES
 889 BUILD_HOTSPOT
 890 HOTSPOT_DIST
 891 BUILD_OUTPUT
 892 JDK_TOPDIR
 893 NASHORN_TOPDIR
 894 HOTSPOT_TOPDIR
 895 JAXWS_TOPDIR
 896 JAXP_TOPDIR
 897 CORBA_TOPDIR
 898 LANGTOOLS_TOPDIR
 899 BUILD_JDK
 900 CREATE_BUILDJDK
 901 BOOT_JDK_BITS
 902 JAVAC_FLAGS
 903 BOOT_JDK_MODULAR
 904 BOOT_JDK_SOURCETARGET
 905 JARSIGNER
 906 JAR
 907 JAVAH
 908 JAVAC
 909 JAVA
 910 BOOT_JDK
 911 JAVA_CHECK
 912 JAVAC_CHECK
 913 VERSION_IS_GA
 914 VERSION_SHORT
 915 VERSION_STRING
 916 VERSION_NUMBER_FOUR_POSITIONS
 917 VERSION_NUMBER
 918 VERSION_OPT
 919 VERSION_BUILD
 920 VERSION_PRE
 921 VERSION_PATCH
 922 VERSION_SECURITY
 923 VERSION_MINOR
 924 VERSION_MAJOR
 925 MACOSX_BUNDLE_ID_BASE
 926 MACOSX_BUNDLE_NAME_BASE
 927 HOTSPOT_VM_DISTRO
 928 COMPANY_NAME
 929 JDK_RC_PLATFORM_NAME
 930 PRODUCT_SUFFIX
 931 PRODUCT_NAME
 932 LAUNCHER_NAME
 933 JLINK_KEEP_PACKAGED_MODULES
 934 COPYRIGHT_YEAR
 935 COMPRESS_JARS
 936 INCLUDE_SA
 937 UNLIMITED_CRYPTO
 938 CACERTS_FILE
 939 BUILD_HEADLESS
 940 SUPPORT_HEADFUL
 941 SUPPORT_HEADLESS
 942 DEFAULT_MAKE_TARGET
 943 OS_VERSION_MICRO
 944 OS_VERSION_MINOR
 945 OS_VERSION_MAJOR
 946 PKG_CONFIG
 947 BASH_ARGS
 948 SETFILE
 949 CODESIGN
 950 XATTR
 951 DSYMUTIL
 952 IS_GNU_TIME
 953 PATCH
 954 DTRACE
 955 TIME
 956 STAT
 957 HG
 958 READELF
 959 OTOOL
 960 LDD
 961 ZIP
 962 UNZIP
 963 FIND_DELETE
 964 OUTPUT_SYNC
 965 OUTPUT_SYNC_SUPPORTED
 966 CHECK_TOOLSDIR_MAKE
 967 CHECK_TOOLSDIR_GMAKE
 968 CHECK_MAKE
 969 CHECK_GMAKE
 970 MAKE
 971 PKGHANDLER
 972 CONFIGURESUPPORT_OUTPUTDIR
 973 OUTPUT_ROOT
 974 CONF_NAME
 975 SPEC
 976 SDKROOT
 977 XCODEBUILD
 978 VALID_JVM_VARIANTS
 979 JVM_VARIANTS
 980 DEBUG_LEVEL
 981 HOTSPOT_DEBUG_LEVEL
 982 JDK_VARIANT
 983 SET_OPENJDK
 984 USERNAME
 985 CANONICAL_TOPDIR
 986 ORIGINAL_TOPDIR
 987 TOPDIR
 988 PATH_SEP
 989 ZERO_ARCHDEF
 990 HOTSPOT_BUILD_CPU_DEFINE
 991 HOTSPOT_BUILD_CPU_ARCH
 992 HOTSPOT_BUILD_CPU
 993 HOTSPOT_BUILD_OS_TYPE
 994 HOTSPOT_BUILD_OS
 995 OPENJDK_BUILD_OS_EXPORT_DIR
 996 OPENJDK_BUILD_CPU_JLI_CFLAGS
 997 OPENJDK_BUILD_CPU_OSARCH
 998 OPENJDK_BUILD_CPU_ISADIR
 999 OPENJDK_BUILD_CPU_LIBDIR
1000 OPENJDK_BUILD_CPU_LEGACY_LIB
1001 OPENJDK_BUILD_CPU_LEGACY
1002 HOTSPOT_TARGET_CPU_DEFINE
1003 HOTSPOT_TARGET_CPU_ARCH
1004 HOTSPOT_TARGET_CPU
1005 HOTSPOT_TARGET_OS_TYPE
1006 HOTSPOT_TARGET_OS
1007 DEFINE_CROSS_COMPILE_ARCH
1008 LP64
1009 OPENJDK_TARGET_OS_EXPORT_DIR
1010 OPENJDK_TARGET_CPU_JLI_CFLAGS
1011 OPENJDK_TARGET_CPU_OSARCH
1012 OPENJDK_TARGET_CPU_ISADIR
1013 OPENJDK_TARGET_CPU_LIBDIR
1014 OPENJDK_TARGET_CPU_LEGACY_LIB
1015 OPENJDK_TARGET_CPU_LEGACY
1016 REQUIRED_OS_VERSION
1017 REQUIRED_OS_NAME
1018 COMPILE_TYPE
1019 OPENJDK_TARGET_CPU_ENDIAN
1020 OPENJDK_TARGET_CPU_BITS
1021 OPENJDK_TARGET_CPU_ARCH
1022 OPENJDK_TARGET_CPU
1023 OPENJDK_TARGET_OS_ENV
1024 OPENJDK_TARGET_OS_TYPE
1025 OPENJDK_TARGET_OS
1026 OPENJDK_BUILD_CPU_ENDIAN
1027 OPENJDK_BUILD_CPU_BITS
1028 OPENJDK_BUILD_CPU_ARCH
1029 OPENJDK_BUILD_CPU
1030 OPENJDK_BUILD_OS_ENV
1031 OPENJDK_BUILD_OS_TYPE
1032 OPENJDK_BUILD_OS
1033 OPENJDK_BUILD_AUTOCONF_NAME
1034 OPENJDK_TARGET_AUTOCONF_NAME
1035 target_os
1036 target_vendor
1037 target_cpu
1038 target
1039 host_os
1040 host_vendor
1041 host_cpu
1042 host
1043 build_os
1044 build_vendor
1045 build_cpu
1046 build
1047 NICE
1048 CPIO
1049 DF
1050 READLINK
1051 CYGPATH
1052 SED
1053 FGREP
1054 EGREP
1055 GREP
1056 AWK
1057 XARGS
1058 WHICH
1059 WC
1060 UNIQ
1061 UNAME
1062 TR
1063 TOUCH
1064 TEE
1065 TAR
1066 TAIL
1067 SORT
1068 SH
1069 RMDIR
1070 RM
1071 PRINTF
1072 NAWK
1073 MV
1074 MKTEMP
1075 MKDIR
1076 LS
1077 LN
1078 HEAD
1079 FIND
1080 FILE
1081 EXPR
1082 ECHO
1083 DIRNAME
1084 DIFF
1085 DATE
1086 CUT
1087 CP
1088 COMM
1089 CMP
1090 CHMOD
1091 CAT
1092 BASH
1093 BASENAME
1094 DATE_WHEN_CONFIGURED
1095 ORIGINAL_PATH
1096 CONFIGURE_COMMAND_LINE
1097 target_alias
1098 host_alias
1099 build_alias
1100 LIBS
1101 ECHO_T
1102 ECHO_N
1103 ECHO_C
1104 DEFS
1105 mandir
1106 localedir
1107 libdir
1108 psdir
1109 pdfdir
1110 dvidir
1111 htmldir
1112 infodir
1113 docdir
1114 oldincludedir
1115 includedir
1116 localstatedir
1117 sharedstatedir
1118 sysconfdir
1119 datadir
1120 datarootdir
1121 libexecdir
1122 sbindir
1123 bindir
1124 program_transform_name
1125 prefix
1126 exec_prefix
1127 PACKAGE_URL
1128 PACKAGE_BUGREPORT
1129 PACKAGE_STRING
1130 PACKAGE_VERSION
1131 PACKAGE_TARNAME
1132 PACKAGE_NAME
1133 PATH_SEPARATOR
1134 SHELL'
1135 ac_subst_files=''
1136 ac_user_opts='
1137 enable_option_checking
1138 with_target_bits
1139 enable_openjdk_only
1140 with_custom_make_dir
1141 with_jdk_variant
1142 enable_debug
1143 with_debug_level
1144 with_jvm_variants
1145 with_devkit
1146 with_sys_root
1147 with_sysroot
1148 with_tools_dir
1149 with_toolchain_path
1150 with_extra_path
1151 with_sdk_name
1152 with_conf_name
1153 with_output_sync
1154 with_default_make_target
1155 enable_headful
1156 with_cacerts_file
1157 enable_unlimited_crypto
1158 with_copyright_year
1159 enable_keep_packaged_modules
1160 with_milestone
1161 with_update_version
1162 with_user_release_suffix
1163 with_build_number
1164 with_version_string
1165 with_version_pre
1166 with_version_opt
1167 with_version_build
1168 with_version_major
1169 with_version_minor
1170 with_version_security
1171 with_version_patch
1172 with_boot_jdk
1173 with_build_jdk
1174 with_add_source_root
1175 with_override_source_root
1176 with_adds_and_overrides
1177 with_override_langtools
1178 with_override_corba
1179 with_override_jaxp
1180 with_override_jaxws
1181 with_override_hotspot
1182 with_override_nashorn
1183 with_override_jdk
1184 with_import_hotspot
1185 with_import_modules
1186 enable_static_build
1187 with_toolchain_type
1188 with_extra_cflags
1189 with_extra_cxxflags
1190 with_extra_ldflags
1191 with_toolchain_version
1192 with_build_devkit
1193 with_jtreg
1194 enable_warnings_as_errors
1195 with_native_debug_symbols
1196 enable_debug_symbols
1197 enable_zip_debug_info
1198 enable_native_coverage
1199 enable_dtrace
1200 with_jvm_features
1201 with_jvm_interpreter
1202 with_stdc__lib
1203 with_msvcr_dll
1204 with_msvcp_dll
1205 with_x
1206 with_cups
1207 with_cups_include
1208 with_freetype
1209 with_freetype_include
1210 with_freetype_lib
1211 with_freetype_src
1212 enable_freetype_bundling
1213 with_alsa
1214 with_alsa_include
1215 with_alsa_lib
1216 with_libffi
1217 with_libffi_include
1218 with_libffi_lib
1219 with_libjpeg
1220 with_giflib
1221 with_libpng
1222 with_zlib
1223 with_lcms
1224 with_dxsdk
1225 with_dxsdk_lib
1226 with_dxsdk_include
1227 enable_jtreg_failure_handler
1228 enable_new_hotspot_build
1229 enable_hotspot_test_in_build
1230 with_num_cores
1231 with_memory_size
1232 with_jobs
1233 with_test_jobs
1234 with_boot_jdk_jvmargs
1235 with_sjavac_server_java
1236 enable_sjavac
1237 enable_javac_server
1238 enable_icecc
1239 enable_precompiled_headers
1240 enable_ccache
1241 with_ccache_dir
1242 '
1243       ac_precious_vars='build_alias
1244 host_alias
1245 target_alias
1246 BASENAME
1247 BASH
1248 CAT
1249 CHMOD
1250 CMP
1251 COMM
1252 CP
1253 CUT
1254 DATE
1255 DIFF
1256 DIRNAME
1257 ECHO
1258 EXPR
1259 FILE
1260 FIND
1261 HEAD
1262 LN
1263 LS
1264 MKDIR
1265 MKTEMP
1266 MV
1267 NAWK
1268 PRINTF
1269 RM
1270 RMDIR
1271 SH
1272 SORT
1273 TAIL
1274 TAR
1275 TEE
1276 TOUCH
1277 TR
1278 UNAME
1279 UNIQ
1280 WC
1281 WHICH
1282 XARGS
1283 AWK
1284 GREP
1285 EGREP
1286 FGREP
1287 SED
1288 CYGPATH
1289 READLINK
1290 DF
1291 CPIO
1292 NICE
1293 MAKE
1294 UNZIP
1295 ZIP
1296 LDD
1297 OTOOL
1298 READELF
1299 HG
1300 STAT
1301 TIME
1302 DTRACE
1303 PATCH
1304 DSYMUTIL
1305 XATTR
1306 CODESIGN
1307 SETFILE
1308 PKG_CONFIG
1309 JAVA
1310 JAVAC
1311 JAVAH
1312 JAR
1313 JARSIGNER
1314 CC
1315 CFLAGS
1316 LDFLAGS
1317 LIBS
1318 CPPFLAGS
1319 CXX
1320 CXXFLAGS
1321 CCC
1322 CPP
1323 CXXCPP
1324 AS
1325 AR
1326 LIPO
1327 STRIP
1328 NM
1329 GNM
1330 OBJCOPY
1331 OBJDUMP
1332 BUILD_CC
1333 BUILD_CXX
1334 BUILD_NM
1335 BUILD_AR
1336 BUILD_OBJCOPY
1337 BUILD_STRIP
1338 JTREGEXE
1339 XMKMF
1340 FREETYPE_CFLAGS
1341 FREETYPE_LIBS
1342 ALSA_CFLAGS
1343 ALSA_LIBS
1344 LIBFFI_CFLAGS
1345 LIBFFI_LIBS
1346 PNG_CFLAGS
1347 PNG_LIBS
1348 LCMS_CFLAGS
1349 LCMS_LIBS
1350 ICECC_CMD
1351 ICECC_CREATE_ENV
1352 ICECC_WRAPPER
1353 CCACHE'
1354 
1355 
1356 # Initialize some variables set by options.
1357 ac_init_help=
1358 ac_init_version=false
1359 ac_unrecognized_opts=
1360 ac_unrecognized_sep=
1361 # The variables have the same names as the options, with
1362 # dashes changed to underlines.
1363 cache_file=/dev/null
1364 exec_prefix=NONE
1365 no_create=
1366 no_recursion=
1367 prefix=NONE
1368 program_prefix=NONE
1369 program_suffix=NONE
1370 program_transform_name=s,x,x,
1371 silent=
1372 site=
1373 srcdir=
1374 verbose=
1375 x_includes=NONE
1376 x_libraries=NONE
1377 
1378 # Installation directory options.
1379 # These are left unexpanded so users can "make install exec_prefix=/foo"
1380 # and all the variables that are supposed to be based on exec_prefix
1381 # by default will actually change.
1382 # Use braces instead of parens because sh, perl, etc. also accept them.
1383 # (The list follows the same order as the GNU Coding Standards.)
1384 bindir='${exec_prefix}/bin'
1385 sbindir='${exec_prefix}/sbin'
1386 libexecdir='${exec_prefix}/libexec'
1387 datarootdir='${prefix}/share'
1388 datadir='${datarootdir}'
1389 sysconfdir='${prefix}/etc'
1390 sharedstatedir='${prefix}/com'
1391 localstatedir='${prefix}/var'
1392 includedir='${prefix}/include'
1393 oldincludedir='/usr/include'
1394 docdir='${datarootdir}/doc/${PACKAGE_TARNAME}'
1395 infodir='${datarootdir}/info'
1396 htmldir='${docdir}'
1397 dvidir='${docdir}'
1398 pdfdir='${docdir}'
1399 psdir='${docdir}'
1400 libdir='${exec_prefix}/lib'
1401 localedir='${datarootdir}/locale'
1402 mandir='${datarootdir}/man'
1403 
1404 ac_prev=
1405 ac_dashdash=
1406 for ac_option
1407 do
1408   # If the previous option needs an argument, assign it.
1409   if test -n "$ac_prev"; then
1410     eval $ac_prev=\$ac_option
1411     ac_prev=
1412     continue
1413   fi
1414 
1415   case $ac_option in
1416   *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
1417   *=)   ac_optarg= ;;
1418   *)    ac_optarg=yes ;;
1419   esac
1420 
1421   # Accept the important Cygnus configure options, so we can diagnose typos.
1422 
1423   case $ac_dashdash$ac_option in
1424   --)
1425     ac_dashdash=yes ;;
1426 
1427   -bindir | --bindir | --bindi | --bind | --bin | --bi)
1428     ac_prev=bindir ;;
1429   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
1430     bindir=$ac_optarg ;;
1431 
1432   -build | --build | --buil | --bui | --bu)
1433     ac_prev=build_alias ;;
1434   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
1435     build_alias=$ac_optarg ;;
1436 
1437   -cache-file | --cache-file | --cache-fil | --cache-fi \
1438   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
1439     ac_prev=cache_file ;;
1440   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
1441   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
1442     cache_file=$ac_optarg ;;
1443 
1444   --config-cache | -C)
1445     cache_file=config.cache ;;
1446 
1447   -datadir | --datadir | --datadi | --datad)
1448     ac_prev=datadir ;;
1449   -datadir=* | --datadir=* | --datadi=* | --datad=*)
1450     datadir=$ac_optarg ;;
1451 
1452   -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \
1453   | --dataroo | --dataro | --datar)
1454     ac_prev=datarootdir ;;
1455   -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \
1456   | --dataroot=* | --dataroo=* | --dataro=* | --datar=*)
1457     datarootdir=$ac_optarg ;;
1458 
1459   -disable-* | --disable-*)
1460     ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
1461     # Reject names that are not valid shell variable names.
1462     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1463       as_fn_error $? "invalid feature name: $ac_useropt"
1464     ac_useropt_orig=$ac_useropt
1465     ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1466     case $ac_user_opts in
1467       *"
1468 "enable_$ac_useropt"
1469 "*) ;;
1470       *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig"
1471          ac_unrecognized_sep=', ';;
1472     esac
1473     eval enable_$ac_useropt=no ;;
1474 
1475   -docdir | --docdir | --docdi | --doc | --do)
1476     ac_prev=docdir ;;
1477   -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*)
1478     docdir=$ac_optarg ;;
1479 
1480   -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv)
1481     ac_prev=dvidir ;;
1482   -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*)
1483     dvidir=$ac_optarg ;;
1484 
1485   -enable-* | --enable-*)
1486     ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
1487     # Reject names that are not valid shell variable names.
1488     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1489       as_fn_error $? "invalid feature name: $ac_useropt"
1490     ac_useropt_orig=$ac_useropt
1491     ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1492     case $ac_user_opts in
1493       *"
1494 "enable_$ac_useropt"
1495 "*) ;;
1496       *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig"
1497          ac_unrecognized_sep=', ';;
1498     esac
1499     eval enable_$ac_useropt=\$ac_optarg ;;
1500 
1501   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
1502   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
1503   | --exec | --exe | --ex)
1504     ac_prev=exec_prefix ;;
1505   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
1506   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
1507   | --exec=* | --exe=* | --ex=*)
1508     exec_prefix=$ac_optarg ;;
1509 
1510   -gas | --gas | --ga | --g)
1511     # Obsolete; use --with-gas.
1512     with_gas=yes ;;
1513 
1514   -help | --help | --hel | --he | -h)
1515     ac_init_help=long ;;
1516   -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
1517     ac_init_help=recursive ;;
1518   -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
1519     ac_init_help=short ;;
1520 
1521   -host | --host | --hos | --ho)
1522     ac_prev=host_alias ;;
1523   -host=* | --host=* | --hos=* | --ho=*)
1524     host_alias=$ac_optarg ;;
1525 
1526   -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht)
1527     ac_prev=htmldir ;;
1528   -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \
1529   | --ht=*)
1530     htmldir=$ac_optarg ;;
1531 
1532   -includedir | --includedir | --includedi | --included | --include \
1533   | --includ | --inclu | --incl | --inc)
1534     ac_prev=includedir ;;
1535   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
1536   | --includ=* | --inclu=* | --incl=* | --inc=*)
1537     includedir=$ac_optarg ;;
1538 
1539   -infodir | --infodir | --infodi | --infod | --info | --inf)
1540     ac_prev=infodir ;;
1541   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
1542     infodir=$ac_optarg ;;
1543 
1544   -libdir | --libdir | --libdi | --libd)
1545     ac_prev=libdir ;;
1546   -libdir=* | --libdir=* | --libdi=* | --libd=*)
1547     libdir=$ac_optarg ;;
1548 
1549   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
1550   | --libexe | --libex | --libe)
1551     ac_prev=libexecdir ;;
1552   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
1553   | --libexe=* | --libex=* | --libe=*)
1554     libexecdir=$ac_optarg ;;
1555 
1556   -localedir | --localedir | --localedi | --localed | --locale)
1557     ac_prev=localedir ;;
1558   -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*)
1559     localedir=$ac_optarg ;;
1560 
1561   -localstatedir | --localstatedir | --localstatedi | --localstated \
1562   | --localstate | --localstat | --localsta | --localst | --locals)
1563     ac_prev=localstatedir ;;
1564   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
1565   | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*)
1566     localstatedir=$ac_optarg ;;
1567 
1568   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
1569     ac_prev=mandir ;;
1570   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
1571     mandir=$ac_optarg ;;
1572 
1573   -nfp | --nfp | --nf)
1574     # Obsolete; use --without-fp.
1575     with_fp=no ;;
1576 
1577   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
1578   | --no-cr | --no-c | -n)
1579     no_create=yes ;;
1580 
1581   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
1582   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
1583     no_recursion=yes ;;
1584 
1585   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
1586   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
1587   | --oldin | --oldi | --old | --ol | --o)
1588     ac_prev=oldincludedir ;;
1589   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
1590   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
1591   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
1592     oldincludedir=$ac_optarg ;;
1593 
1594   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
1595     ac_prev=prefix ;;
1596   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
1597     prefix=$ac_optarg ;;
1598 
1599   -program-prefix | --program-prefix | --program-prefi | --program-pref \
1600   | --program-pre | --program-pr | --program-p)
1601     ac_prev=program_prefix ;;
1602   -program-prefix=* | --program-prefix=* | --program-prefi=* \
1603   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
1604     program_prefix=$ac_optarg ;;
1605 
1606   -program-suffix | --program-suffix | --program-suffi | --program-suff \
1607   | --program-suf | --program-su | --program-s)
1608     ac_prev=program_suffix ;;
1609   -program-suffix=* | --program-suffix=* | --program-suffi=* \
1610   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
1611     program_suffix=$ac_optarg ;;
1612 
1613   -program-transform-name | --program-transform-name \
1614   | --program-transform-nam | --program-transform-na \
1615   | --program-transform-n | --program-transform- \
1616   | --program-transform | --program-transfor \
1617   | --program-transfo | --program-transf \
1618   | --program-trans | --program-tran \
1619   | --progr-tra | --program-tr | --program-t)
1620     ac_prev=program_transform_name ;;
1621   -program-transform-name=* | --program-transform-name=* \
1622   | --program-transform-nam=* | --program-transform-na=* \
1623   | --program-transform-n=* | --program-transform-=* \
1624   | --program-transform=* | --program-transfor=* \
1625   | --program-transfo=* | --program-transf=* \
1626   | --program-trans=* | --program-tran=* \
1627   | --progr-tra=* | --program-tr=* | --program-t=*)
1628     program_transform_name=$ac_optarg ;;
1629 
1630   -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd)
1631     ac_prev=pdfdir ;;
1632   -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*)
1633     pdfdir=$ac_optarg ;;
1634 
1635   -psdir | --psdir | --psdi | --psd | --ps)
1636     ac_prev=psdir ;;
1637   -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)
1638     psdir=$ac_optarg ;;
1639 
1640   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1641   | -silent | --silent | --silen | --sile | --sil)
1642     silent=yes ;;
1643 
1644   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
1645     ac_prev=sbindir ;;
1646   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
1647   | --sbi=* | --sb=*)
1648     sbindir=$ac_optarg ;;
1649 
1650   -sharedstatedir | --sharedstatedir | --sharedstatedi \
1651   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
1652   | --sharedst | --shareds | --shared | --share | --shar \
1653   | --sha | --sh)
1654     ac_prev=sharedstatedir ;;
1655   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
1656   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
1657   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
1658   | --sha=* | --sh=*)
1659     sharedstatedir=$ac_optarg ;;
1660 
1661   -site | --site | --sit)
1662     ac_prev=site ;;
1663   -site=* | --site=* | --sit=*)
1664     site=$ac_optarg ;;
1665 
1666   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
1667     ac_prev=srcdir ;;
1668   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
1669     srcdir=$ac_optarg ;;
1670 
1671   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
1672   | --syscon | --sysco | --sysc | --sys | --sy)
1673     ac_prev=sysconfdir ;;
1674   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
1675   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
1676     sysconfdir=$ac_optarg ;;
1677 
1678   -target | --target | --targe | --targ | --tar | --ta | --t)
1679     ac_prev=target_alias ;;
1680   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
1681     target_alias=$ac_optarg ;;
1682 
1683   -v | -verbose | --verbose | --verbos | --verbo | --verb)
1684     verbose=yes ;;
1685 
1686   -version | --version | --versio | --versi | --vers | -V)
1687     ac_init_version=: ;;
1688 
1689   -with-* | --with-*)
1690     ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
1691     # Reject names that are not valid shell variable names.
1692     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1693       as_fn_error $? "invalid package name: $ac_useropt"
1694     ac_useropt_orig=$ac_useropt
1695     ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1696     case $ac_user_opts in
1697       *"
1698 "with_$ac_useropt"
1699 "*) ;;
1700       *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig"
1701          ac_unrecognized_sep=', ';;
1702     esac
1703     eval with_$ac_useropt=\$ac_optarg ;;
1704 
1705   -without-* | --without-*)
1706     ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'`
1707     # Reject names that are not valid shell variable names.
1708     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1709       as_fn_error $? "invalid package name: $ac_useropt"
1710     ac_useropt_orig=$ac_useropt
1711     ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1712     case $ac_user_opts in
1713       *"
1714 "with_$ac_useropt"
1715 "*) ;;
1716       *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig"
1717          ac_unrecognized_sep=', ';;
1718     esac
1719     eval with_$ac_useropt=no ;;
1720 
1721   --x)
1722     # Obsolete; use --with-x.
1723     with_x=yes ;;
1724 
1725   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
1726   | --x-incl | --x-inc | --x-in | --x-i)
1727     ac_prev=x_includes ;;
1728   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
1729   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
1730     x_includes=$ac_optarg ;;
1731 
1732   -x-libraries | --x-libraries | --x-librarie | --x-librari \
1733   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
1734     ac_prev=x_libraries ;;
1735   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
1736   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
1737     x_libraries=$ac_optarg ;;
1738 
1739   -*) as_fn_error $? "unrecognized option: \`$ac_option'
1740 Try \`$0 --help' for more information"
1741     ;;
1742 
1743   *=*)
1744     ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
1745     # Reject names that are not valid shell variable names.
1746     case $ac_envvar in #(
1747       '' | [0-9]* | *[!_$as_cr_alnum]* )
1748       as_fn_error $? "invalid variable name: \`$ac_envvar'" ;;
1749     esac
1750     eval $ac_envvar=\$ac_optarg
1751     export $ac_envvar ;;
1752 
1753   *)
1754     # FIXME: should be removed in autoconf 3.0.
1755     $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2
1756     expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
1757       $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2
1758     : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}"
1759     ;;
1760 
1761   esac
1762 done
1763 
1764 if test -n "$ac_prev"; then
1765   ac_option=--`echo $ac_prev | sed 's/_/-/g'`
1766   as_fn_error $? "missing argument to $ac_option"
1767 fi
1768 
1769 if test -n "$ac_unrecognized_opts"; then
1770   case $enable_option_checking in
1771     no) ;;
1772     fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;;
1773     *)     $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
1774   esac
1775 fi
1776 
1777 # Check all directory arguments for consistency.
1778 for ac_var in   exec_prefix prefix bindir sbindir libexecdir datarootdir \
1779                 datadir sysconfdir sharedstatedir localstatedir includedir \
1780                 oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
1781                 libdir localedir mandir
1782 do
1783   eval ac_val=\$$ac_var
1784   # Remove trailing slashes.
1785   case $ac_val in
1786     */ )
1787       ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'`
1788       eval $ac_var=\$ac_val;;
1789   esac
1790   # Be sure to have absolute directory names.
1791   case $ac_val in
1792     [\\/$]* | ?:[\\/]* )  continue;;
1793     NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
1794   esac
1795   as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val"
1796 done
1797 
1798 # There might be people who depend on the old broken behavior: `$host'
1799 # used to hold the argument of --host etc.
1800 # FIXME: To remove some day.
1801 build=$build_alias
1802 host=$host_alias
1803 target=$target_alias
1804 
1805 # FIXME: To remove some day.
1806 if test "x$host_alias" != x; then
1807   if test "x$build_alias" = x; then
1808     cross_compiling=maybe
1809   elif test "x$build_alias" != "x$host_alias"; then
1810     cross_compiling=yes
1811   fi
1812 fi
1813 
1814 ac_tool_prefix=
1815 test -n "$host_alias" && ac_tool_prefix=$host_alias-
1816 
1817 test "$silent" = yes && exec 6>/dev/null
1818 
1819 
1820 ac_pwd=`pwd` && test -n "$ac_pwd" &&
1821 ac_ls_di=`ls -di .` &&
1822 ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
1823   as_fn_error $? "working directory cannot be determined"
1824 test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
1825   as_fn_error $? "pwd does not report name of working directory"
1826 
1827 
1828 # Find the source files, if location was not specified.
1829 if test -z "$srcdir"; then
1830   ac_srcdir_defaulted=yes
1831   # Try the directory containing this script, then the parent directory.
1832   ac_confdir=`$as_dirname -- "$as_myself" ||
1833 $as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
1834          X"$as_myself" : 'X\(//\)[^/]' \| \
1835          X"$as_myself" : 'X\(//\)$' \| \
1836          X"$as_myself" : 'X\(/\)' \| . 2>/dev/null ||
1837 $as_echo X"$as_myself" |
1838     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
1839             s//\1/
1840             q
1841           }
1842           /^X\(\/\/\)[^/].*/{
1843             s//\1/
1844             q
1845           }
1846           /^X\(\/\/\)$/{
1847             s//\1/
1848             q
1849           }
1850           /^X\(\/\).*/{
1851             s//\1/
1852             q
1853           }
1854           s/.*/./; q'`
1855   srcdir=$ac_confdir
1856   if test ! -r "$srcdir/$ac_unique_file"; then
1857     srcdir=..
1858   fi
1859 else
1860   ac_srcdir_defaulted=no
1861 fi
1862 if test ! -r "$srcdir/$ac_unique_file"; then
1863   test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
1864   as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir"
1865 fi
1866 ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
1867 ac_abs_confdir=`(
1868         cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg"
1869         pwd)`
1870 # When building in place, set srcdir=.
1871 if test "$ac_abs_confdir" = "$ac_pwd"; then
1872   srcdir=.
1873 fi
1874 # Remove unnecessary trailing slashes from srcdir.
1875 # Double slashes in file names in object file debugging info
1876 # mess up M-x gdb in Emacs.
1877 case $srcdir in
1878 */) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;;
1879 esac
1880 for ac_var in $ac_precious_vars; do
1881   eval ac_env_${ac_var}_set=\${${ac_var}+set}
1882   eval ac_env_${ac_var}_value=\$${ac_var}
1883   eval ac_cv_env_${ac_var}_set=\${${ac_var}+set}
1884   eval ac_cv_env_${ac_var}_value=\$${ac_var}
1885 done
1886 
1887 #
1888 # Report the --help message.
1889 #
1890 if test "$ac_init_help" = "long"; then
1891   # Omit some internal or obsolete options to make the list less imposing.
1892   # This message is too long to be a string in the A/UX 3.1 sh.
1893   cat <<_ACEOF
1894 \`configure' configures OpenJDK jdk9 to adapt to many kinds of systems.
1895 
1896 Usage: $0 [OPTION]... [VAR=VALUE]...
1897 
1898 To assign environment variables (e.g., CC, CFLAGS...), specify them as
1899 VAR=VALUE.  See below for descriptions of some of the useful variables.
1900 
1901 Defaults for the options are specified in brackets.
1902 
1903 Configuration:
1904   -h, --help              display this help and exit
1905       --help=short        display options specific to this package
1906       --help=recursive    display the short help of all the included packages
1907   -V, --version           display version information and exit
1908   -q, --quiet, --silent   do not print \`checking ...' messages
1909       --cache-file=FILE   cache test results in FILE [disabled]
1910   -C, --config-cache      alias for \`--cache-file=config.cache'
1911   -n, --no-create         do not create output files
1912       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
1913 
1914 Installation directories:
1915   --prefix=PREFIX         install architecture-independent files in PREFIX
1916                           [$ac_default_prefix]
1917   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
1918                           [PREFIX]
1919 
1920 By default, \`make install' will install all the files in
1921 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
1922 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
1923 for instance \`--prefix=\$HOME'.
1924 
1925 For better control, use the options below.
1926 
1927 Fine tuning of the installation directories:
1928   --bindir=DIR            user executables [EPREFIX/bin]
1929   --sbindir=DIR           system admin executables [EPREFIX/sbin]
1930   --libexecdir=DIR        program executables [EPREFIX/libexec]
1931   --sysconfdir=DIR        read-only single-machine data [PREFIX/etc]
1932   --sharedstatedir=DIR    modifiable architecture-independent data [PREFIX/com]
1933   --localstatedir=DIR     modifiable single-machine data [PREFIX/var]
1934   --libdir=DIR            object code libraries [EPREFIX/lib]
1935   --includedir=DIR        C header files [PREFIX/include]
1936   --oldincludedir=DIR     C header files for non-gcc [/usr/include]
1937   --datarootdir=DIR       read-only arch.-independent data root [PREFIX/share]
1938   --datadir=DIR           read-only architecture-independent data [DATAROOTDIR]
1939   --infodir=DIR           info documentation [DATAROOTDIR/info]
1940   --localedir=DIR         locale-dependent data [DATAROOTDIR/locale]
1941   --mandir=DIR            man documentation [DATAROOTDIR/man]
1942   --docdir=DIR            documentation root [DATAROOTDIR/doc/openjdk]
1943   --htmldir=DIR           html documentation [DOCDIR]
1944   --dvidir=DIR            dvi documentation [DOCDIR]
1945   --pdfdir=DIR            pdf documentation [DOCDIR]
1946   --psdir=DIR             ps documentation [DOCDIR]
1947 _ACEOF
1948 
1949   cat <<\_ACEOF
1950 
1951 X features:
1952   --x-includes=DIR    X include files are in DIR
1953   --x-libraries=DIR   X library files are in DIR
1954 
1955 System types:
1956   --build=BUILD     configure for building on BUILD [guessed]
1957   --host=HOST       cross-compile to build programs to run on HOST [BUILD]
1958   --target=TARGET   configure for building compilers for TARGET [HOST]
1959 _ACEOF
1960 fi
1961 
1962 if test -n "$ac_init_help"; then
1963   case $ac_init_help in
1964      short | recursive ) echo "Configuration of OpenJDK jdk9:";;
1965    esac
1966   cat <<\_ACEOF
1967 
1968 Optional Features:
1969   --disable-option-checking  ignore unrecognized --enable/--with options
1970   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
1971   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
1972   --enable-openjdk-only   suppress building custom source even if present
1973                           [disabled]
1974   --enable-debug          set the debug level to fastdebug (shorthand for
1975                           --with-debug-level=fastdebug) [disabled]
1976   --disable-headful       disable building headful support (graphical UI
1977                           support) [enabled]
1978   --enable-unlimited-crypto
1979                           Enable unlimited crypto policy [disabled]
1980   --disable-keep-packaged-modules
1981                           Do not keep packaged modules in jdk image [enable]
1982   --enable-static-build   enable static library build [disabled]
1983   --disable-warnings-as-errors
1984                           do not consider native warnings to be an error
1985                           [enabled]
1986   --enable-debug-symbols  Deprecated. Option is kept for backwards
1987                           compatibility and is ignored
1988   --enable-zip-debug-info Deprecated. Option is kept for backwards
1989                           compatibility and is ignored
1990   --enable-native-coverage
1991                           enable native compilation with code coverage
1992                           data[disabled]
1993   --enable-dtrace[=yes/no/auto]
1994                           enable dtrace. Default is auto, where dtrace is
1995                           enabled if all dependencies are present.
1996   --disable-freetype-bundling
1997                           disable bundling of the freetype library with the
1998                           build result [enabled on Windows or when using
1999                           --with-freetype, disabled otherwise]
2000   --disable-new-hotspot-build
2001                           disable the new hotspot build system (use the old)
2002                           [enabled]
2003   --enable-hotspot-test-in-build
2004                           run the Queens test after Hotspot build [disabled]
2005   --enable-jtreg-failure-handler
2006                           forces build of the jtreg failure handler to be
2007                           enabled, missing dependencies become fatal errors.
2008                           Default is auto, where the failure handler is built
2009                           if all dependencies are present and otherwise just
2010                           disabled.
2011   --enable-sjavac         use sjavac to do fast incremental compiles
2012                           [disabled]
2013   --disable-javac-server  disable javac server [enabled]
2014   --enable-icecc          enable distribted compilation of native code using
2015                           icecc/icecream [disabled]
2016   --disable-precompiled-headers
2017                           disable using precompiled headers when compiling C++
2018                           [enabled]
2019   --enable-ccache         enable using ccache to speed up recompilations
2020                           [disabled]
2021 
2022 Optional Packages:
2023   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
2024   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
2025   --with-target-bits      build 32-bit or 64-bit binaries (for platforms that
2026                           support it), e.g. --with-target-bits=32 [guessed]
2027   --with-custom-make-dir  Deprecated. Option is kept for backwards
2028                           compatibility and is ignored
2029   --with-jdk-variant      JDK variant to build (normal) [normal]
2030   --with-debug-level      set the debug level (release, fastdebug, slowdebug,
2031                           optimized) [release]
2032   --with-jvm-variants     JVM variants (separated by commas) to build
2033                           (server,client,minimal,core,zero,zeroshark,custom)
2034                           [server]
2035   --with-devkit           use this devkit for compilers, tools and resources
2036   --with-sys-root         alias for --with-sysroot for backwards compatability
2037   --with-sysroot          use this directory as sysroot
2038   --with-tools-dir        alias for --with-toolchain-path for backwards
2039                           compatibility
2040   --with-toolchain-path   prepend these directories when searching for
2041                           toolchain binaries (compilers etc)
2042   --with-extra-path       prepend these directories to the default path
2043   --with-sdk-name         use the platform SDK of the given name. [macosx]
2044   --with-conf-name        use this as the name of the configuration [generated
2045                           from important configuration options]
2046   --with-output-sync      set make output sync type if supported by make.
2047                           [recurse]
2048   --with-default-make-target
2049                           set the default make target [exploded-image]
2050   --with-cacerts-file     specify alternative cacerts file
2051   --with-copyright-year   Set copyright year value for build [current year]
2052   --with-milestone        Deprecated. Option is kept for backwards
2053                           compatibility and is ignored
2054   --with-update-version   Deprecated. Option is kept for backwards
2055                           compatibility and is ignored
2056   --with-user-release-suffix
2057                           Deprecated. Option is kept for backwards
2058                           compatibility and is ignored
2059   --with-build-number     Deprecated. Option is kept for backwards
2060                           compatibility and is ignored
2061   --with-version-string   Set version string [calculated]
2062   --with-version-pre      Set the base part of the version 'PRE' field
2063                           (pre-release identifier) ['internal']
2064   --with-version-opt      Set version 'OPT' field (build metadata)
2065                           [<timestamp>.<user>.<dirname>]
2066   --with-version-build    Set version 'BUILD' field (build number) [not
2067                           specified]
2068   --with-version-major    Set version 'MAJOR' field (first number) [current
2069                           source value]
2070   --with-version-minor    Set version 'MINOR' field (second number) [current
2071                           source value]
2072   --with-version-security Set version 'SECURITY' field (third number) [current
2073                           source value]
2074   --with-version-patch    Set version 'PATCH' field (fourth number) [not
2075                           specified]
2076   --with-boot-jdk         path to Boot JDK (used to bootstrap build) [probed]
2077   --with-build-jdk        path to JDK of same version as is being built[the
2078                           newly built JDK]
2079   --with-add-source-root  Deprecated. Option is kept for backwards
2080                           compatibility and is ignored
2081   --with-override-source-root
2082                           Deprecated. Option is kept for backwards
2083                           compatibility and is ignored
2084   --with-adds-and-overrides
2085                           Deprecated. Option is kept for backwards
2086                           compatibility and is ignored
2087   --with-override-langtools
2088                           Deprecated. Option is kept for backwards
2089                           compatibility and is ignored
2090   --with-override-corba   Deprecated. Option is kept for backwards
2091                           compatibility and is ignored
2092   --with-override-jaxp    Deprecated. Option is kept for backwards
2093                           compatibility and is ignored
2094   --with-override-jaxws   Deprecated. Option is kept for backwards
2095                           compatibility and is ignored
2096   --with-override-hotspot Deprecated. Option is kept for backwards
2097                           compatibility and is ignored
2098   --with-override-nashorn Deprecated. Option is kept for backwards
2099                           compatibility and is ignored
2100   --with-override-jdk     Deprecated. Option is kept for backwards
2101                           compatibility and is ignored
2102   --with-import-hotspot   import hotspot binaries from this jdk image or
2103                           hotspot build dist dir instead of building from
2104                           source
2105   --with-import-modules   import a set of prebuilt modules either as a zip
2106                           file or an exploded directory
2107   --with-toolchain-type   the toolchain type (or family) to use, use '--help'
2108                           to show possible values [platform dependent]
2109   --with-extra-cflags     extra flags to be used when compiling jdk c-files
2110   --with-extra-cxxflags   extra flags to be used when compiling jdk c++-files
2111   --with-extra-ldflags    extra flags to be used when linking jdk
2112   --with-toolchain-version
2113                           the version of the toolchain to look for, use
2114                           '--help' to show possible values [platform
2115                           dependent]
2116   --with-build-devkit     Devkit to use for the build platform toolchain
2117   --with-jtreg            Regression Test Harness [probed]
2118   --with-native-debug-symbols
2119                           set the native debug symbol configuration (none,
2120                           internal, external, zipped) [varying]
2121   --with-jvm-features     additional JVM features to enable (separated by
2122                           comma), use '--help' to show possible values [none]
2123   --with-jvm-interpreter  Deprecated. Option is kept for backwards
2124                           compatibility and is ignored
2125   --with-stdc++lib=<static>,<dynamic>,<default>
2126                           force linking of the C++ runtime on Linux to either
2127                           static or dynamic, default is static with dynamic as
2128                           fallback
2129   --with-msvcr-dll        path to microsoft C runtime dll (msvcr*.dll)
2130                           (Windows only) [probed]
2131   --with-msvcp-dll        path to microsoft C++ runtime dll (msvcp*.dll)
2132                           (Windows only) [probed]
2133   --with-x                use the X Window System
2134   --with-cups             specify prefix directory for the cups package
2135                           (expecting the headers under PATH/include)
2136   --with-cups-include     specify directory for the cups include files
2137   --with-freetype         specify prefix directory for the freetype package
2138                           (expecting the libraries under PATH/lib and the
2139                           headers under PATH/include)
2140   --with-freetype-include specify directory for the freetype include files
2141   --with-freetype-lib     specify directory for the freetype library
2142   --with-freetype-src     specify directory with freetype sources to
2143                           automatically build the library (experimental,
2144                           Windows-only)
2145   --with-alsa             specify prefix directory for the alsa package
2146                           (expecting the libraries under PATH/lib and the
2147                           headers under PATH/include)
2148   --with-alsa-include     specify directory for the alsa include files
2149   --with-alsa-lib         specify directory for the alsa library
2150   --with-libffi           specify prefix directory for the libffi package
2151                           (expecting the libraries under PATH/lib and the
2152                           headers under PATH/include)
2153   --with-libffi-include   specify directory for the libffi include files
2154   --with-libffi-lib       specify directory for the libffi library
2155   --with-libjpeg          use libjpeg from build system or OpenJDK source
2156                           (system, bundled) [bundled]
2157   --with-giflib           use giflib from build system or OpenJDK source
2158                           (system, bundled) [bundled]
2159   --with-libpng           use libpng from build system or OpenJDK source
2160                           (system, bundled) [bundled]
2161   --with-zlib             use zlib from build system or OpenJDK source
2162                           (system, bundled) [bundled]
2163   --with-lcms             use lcms2 from build system or OpenJDK source
2164                           (system, bundled) [bundled]
2165   --with-dxsdk            Deprecated. Option is kept for backwards
2166                           compatibility and is ignored
2167   --with-dxsdk-lib        Deprecated. Option is kept for backwards
2168                           compatibility and is ignored
2169   --with-dxsdk-include    Deprecated. Option is kept for backwards
2170                           compatibility and is ignored
2171   --with-num-cores        number of cores in the build system, e.g.
2172                           --with-num-cores=8 [probed]
2173   --with-memory-size      memory (in MB) available in the build system, e.g.
2174                           --with-memory-size=1024 [probed]
2175   --with-jobs             number of parallel jobs to let make run [calculated
2176                           based on cores and memory]
2177   --with-test-jobs        number of parallel tests jobs to run [based on build
2178                           jobs]
2179   --with-boot-jdk-jvmargs specify JVM arguments to be passed to all java
2180                           invocations of boot JDK, overriding the default
2181                           values, e.g --with-boot-jdk-jvmargs="-Xmx8G
2182                           -enableassertions"
2183   --with-sjavac-server-java
2184                           use this java binary for running the sjavac
2185                           background server [Boot JDK java]
2186   --with-ccache-dir       where to store ccache files [~/.ccache]
2187 
2188 Some influential environment variables:
2189   BASENAME    Override default value for BASENAME
2190   BASH        Override default value for BASH
2191   CAT         Override default value for CAT
2192   CHMOD       Override default value for CHMOD
2193   CMP         Override default value for CMP
2194   COMM        Override default value for COMM
2195   CP          Override default value for CP
2196   CUT         Override default value for CUT
2197   DATE        Override default value for DATE
2198   DIFF        Override default value for DIFF
2199   DIRNAME     Override default value for DIRNAME
2200   ECHO        Override default value for ECHO
2201   EXPR        Override default value for EXPR
2202   FILE        Override default value for FILE
2203   FIND        Override default value for FIND
2204   HEAD        Override default value for HEAD
2205   LN          Override default value for LN
2206   LS          Override default value for LS
2207   MKDIR       Override default value for MKDIR
2208   MKTEMP      Override default value for MKTEMP
2209   MV          Override default value for MV
2210   NAWK        Override default value for NAWK
2211   PRINTF      Override default value for PRINTF
2212   RM          Override default value for RM
2213   RMDIR       Override default value for RMDIR
2214   SH          Override default value for SH
2215   SORT        Override default value for SORT
2216   TAIL        Override default value for TAIL
2217   TAR         Override default value for TAR
2218   TEE         Override default value for TEE
2219   TOUCH       Override default value for TOUCH
2220   TR          Override default value for TR
2221   UNAME       Override default value for UNAME
2222   UNIQ        Override default value for UNIQ
2223   WC          Override default value for WC
2224   WHICH       Override default value for WHICH
2225   XARGS       Override default value for XARGS
2226   AWK         Override default value for AWK
2227   GREP        Override default value for GREP
2228   EGREP       Override default value for EGREP
2229   FGREP       Override default value for FGREP
2230   SED         Override default value for SED
2231   CYGPATH     Override default value for CYGPATH
2232   READLINK    Override default value for READLINK
2233   DF          Override default value for DF
2234   CPIO        Override default value for CPIO
2235   NICE        Override default value for NICE
2236   MAKE        Override default value for MAKE
2237   UNZIP       Override default value for UNZIP
2238   ZIP         Override default value for ZIP
2239   LDD         Override default value for LDD
2240   OTOOL       Override default value for OTOOL
2241   READELF     Override default value for READELF
2242   HG          Override default value for HG
2243   STAT        Override default value for STAT
2244   TIME        Override default value for TIME
2245   DTRACE      Override default value for DTRACE
2246   PATCH       Override default value for PATCH
2247   DSYMUTIL    Override default value for DSYMUTIL
2248   XATTR       Override default value for XATTR
2249   CODESIGN    Override default value for CODESIGN
2250   SETFILE     Override default value for SETFILE
2251   PKG_CONFIG  path to pkg-config utility
2252   JAVA        Override default value for JAVA
2253   JAVAC       Override default value for JAVAC
2254   JAVAH       Override default value for JAVAH
2255   JAR         Override default value for JAR
2256   JARSIGNER   Override default value for JARSIGNER
2257   CC          C compiler command
2258   CFLAGS      C compiler flags
2259   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
2260               nonstandard directory <lib dir>
2261   LIBS        libraries to pass to the linker, e.g. -l<library>
2262   CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
2263               you have headers in a nonstandard directory <include dir>
2264   CXX         C++ compiler command
2265   CXXFLAGS    C++ compiler flags
2266   CPP         C preprocessor
2267   CXXCPP      C++ preprocessor
2268   AS          Override default value for AS
2269   AR          Override default value for AR
2270   LIPO        Override default value for LIPO
2271   STRIP       Override default value for STRIP
2272   NM          Override default value for NM
2273   GNM         Override default value for GNM
2274   OBJCOPY     Override default value for OBJCOPY
2275   OBJDUMP     Override default value for OBJDUMP
2276   BUILD_CC    Override default value for BUILD_CC
2277   BUILD_CXX   Override default value for BUILD_CXX
2278   BUILD_NM    Override default value for BUILD_NM
2279   BUILD_AR    Override default value for BUILD_AR
2280   BUILD_OBJCOPY
2281               Override default value for BUILD_OBJCOPY
2282   BUILD_STRIP Override default value for BUILD_STRIP
2283   JTREGEXE    Override default value for JTREGEXE
2284   XMKMF       Path to xmkmf, Makefile generator for X Window System
2285   FREETYPE_CFLAGS
2286               C compiler flags for FREETYPE, overriding pkg-config
2287   FREETYPE_LIBS
2288               linker flags for FREETYPE, overriding pkg-config
2289   ALSA_CFLAGS C compiler flags for ALSA, overriding pkg-config
2290   ALSA_LIBS   linker flags for ALSA, overriding pkg-config
2291   LIBFFI_CFLAGS
2292               C compiler flags for LIBFFI, overriding pkg-config
2293   LIBFFI_LIBS linker flags for LIBFFI, overriding pkg-config
2294   PNG_CFLAGS  C compiler flags for PNG, overriding pkg-config
2295   PNG_LIBS    linker flags for PNG, overriding pkg-config
2296   LCMS_CFLAGS C compiler flags for LCMS, overriding pkg-config
2297   LCMS_LIBS   linker flags for LCMS, overriding pkg-config
2298   ICECC_CMD   Override default value for ICECC_CMD
2299   ICECC_CREATE_ENV
2300               Override default value for ICECC_CREATE_ENV
2301   ICECC_WRAPPER
2302               Override default value for ICECC_WRAPPER
2303   CCACHE      Override default value for CCACHE
2304 
2305 Use these variables to override the choices made by `configure' or to help
2306 it to find libraries and programs with nonstandard names/locations.
2307 
2308 Report bugs to <build-dev@openjdk.java.net>.
2309 OpenJDK home page: <http://openjdk.java.net>.
2310 _ACEOF
2311 ac_status=$?
2312 fi
2313 
2314 if test "$ac_init_help" = "recursive"; then
2315   # If there are subdirs, report their specific --help.
2316   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
2317     test -d "$ac_dir" ||
2318       { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } ||
2319       continue
2320     ac_builddir=.
2321 
2322 case "$ac_dir" in
2323 .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
2324 *)
2325   ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
2326   # A ".." for each directory in $ac_dir_suffix.
2327   ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
2328   case $ac_top_builddir_sub in
2329   "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
2330   *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
2331   esac ;;
2332 esac
2333 ac_abs_top_builddir=$ac_pwd
2334 ac_abs_builddir=$ac_pwd$ac_dir_suffix
2335 # for backward compatibility:
2336 ac_top_builddir=$ac_top_build_prefix
2337 
2338 case $srcdir in
2339   .)  # We are building in place.
2340     ac_srcdir=.
2341     ac_top_srcdir=$ac_top_builddir_sub
2342     ac_abs_top_srcdir=$ac_pwd ;;
2343   [\\/]* | ?:[\\/]* )  # Absolute name.
2344     ac_srcdir=$srcdir$ac_dir_suffix;
2345     ac_top_srcdir=$srcdir
2346     ac_abs_top_srcdir=$srcdir ;;
2347   *) # Relative name.
2348     ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
2349     ac_top_srcdir=$ac_top_build_prefix$srcdir
2350     ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
2351 esac
2352 ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
2353 
2354     cd "$ac_dir" || { ac_status=$?; continue; }
2355     # Check for guested configure.
2356     if test -f "$ac_srcdir/configure.gnu"; then
2357       echo &&
2358       $SHELL "$ac_srcdir/configure.gnu" --help=recursive
2359     elif test -f "$ac_srcdir/configure"; then
2360       echo &&
2361       $SHELL "$ac_srcdir/configure" --help=recursive
2362     else
2363       $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
2364     fi || ac_status=$?
2365     cd "$ac_pwd" || { ac_status=$?; break; }
2366   done
2367 fi
2368 
2369 test -n "$ac_init_help" && exit $ac_status
2370 if $ac_init_version; then
2371   cat <<\_ACEOF
2372 OpenJDK configure jdk9
2373 generated by GNU Autoconf 2.69
2374 
2375 Copyright (C) 2012 Free Software Foundation, Inc.
2376 This configure script is free software; the Free Software Foundation
2377 gives unlimited permission to copy, distribute and modify it.
2378 _ACEOF
2379   exit
2380 fi
2381 
2382 ## ------------------------ ##
2383 ## Autoconf initialization. ##
2384 ## ------------------------ ##
2385 
2386 # ac_fn_c_try_compile LINENO
2387 # --------------------------
2388 # Try to compile conftest.$ac_ext, and return whether this succeeded.
2389 ac_fn_c_try_compile ()
2390 {
2391   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2392   rm -f conftest.$ac_objext
2393   if { { ac_try="$ac_compile"
2394 case "(($ac_try" in
2395   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2396   *) ac_try_echo=$ac_try;;
2397 esac
2398 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2399 $as_echo "$ac_try_echo"; } >&5
2400   (eval "$ac_compile") 2>conftest.err
2401   ac_status=$?
2402   if test -s conftest.err; then
2403     grep -v '^ *+' conftest.err >conftest.er1
2404     cat conftest.er1 >&5
2405     mv -f conftest.er1 conftest.err
2406   fi
2407   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2408   test $ac_status = 0; } && {
2409          test -z "$ac_c_werror_flag" ||
2410          test ! -s conftest.err
2411        } && test -s conftest.$ac_objext; then :
2412   ac_retval=0
2413 else
2414   $as_echo "$as_me: failed program was:" >&5
2415 sed 's/^/| /' conftest.$ac_ext >&5
2416 
2417         ac_retval=1
2418 fi
2419   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2420   as_fn_set_status $ac_retval
2421 
2422 } # ac_fn_c_try_compile
2423 
2424 # ac_fn_cxx_try_compile LINENO
2425 # ----------------------------
2426 # Try to compile conftest.$ac_ext, and return whether this succeeded.
2427 ac_fn_cxx_try_compile ()
2428 {
2429   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2430   rm -f conftest.$ac_objext
2431   if { { ac_try="$ac_compile"
2432 case "(($ac_try" in
2433   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2434   *) ac_try_echo=$ac_try;;
2435 esac
2436 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2437 $as_echo "$ac_try_echo"; } >&5
2438   (eval "$ac_compile") 2>conftest.err
2439   ac_status=$?
2440   if test -s conftest.err; then
2441     grep -v '^ *+' conftest.err >conftest.er1
2442     cat conftest.er1 >&5
2443     mv -f conftest.er1 conftest.err
2444   fi
2445   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2446   test $ac_status = 0; } && {
2447          test -z "$ac_cxx_werror_flag" ||
2448          test ! -s conftest.err
2449        } && test -s conftest.$ac_objext; then :
2450   ac_retval=0
2451 else
2452   $as_echo "$as_me: failed program was:" >&5
2453 sed 's/^/| /' conftest.$ac_ext >&5
2454 
2455         ac_retval=1
2456 fi
2457   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2458   as_fn_set_status $ac_retval
2459 
2460 } # ac_fn_cxx_try_compile
2461 
2462 # ac_fn_c_try_cpp LINENO
2463 # ----------------------
2464 # Try to preprocess conftest.$ac_ext, and return whether this succeeded.
2465 ac_fn_c_try_cpp ()
2466 {
2467   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2468   if { { ac_try="$ac_cpp conftest.$ac_ext"
2469 case "(($ac_try" in
2470   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2471   *) ac_try_echo=$ac_try;;
2472 esac
2473 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2474 $as_echo "$ac_try_echo"; } >&5
2475   (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
2476   ac_status=$?
2477   if test -s conftest.err; then
2478     grep -v '^ *+' conftest.err >conftest.er1
2479     cat conftest.er1 >&5
2480     mv -f conftest.er1 conftest.err
2481   fi
2482   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2483   test $ac_status = 0; } > conftest.i && {
2484          test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
2485          test ! -s conftest.err
2486        }; then :
2487   ac_retval=0
2488 else
2489   $as_echo "$as_me: failed program was:" >&5
2490 sed 's/^/| /' conftest.$ac_ext >&5
2491 
2492     ac_retval=1
2493 fi
2494   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2495   as_fn_set_status $ac_retval
2496 
2497 } # ac_fn_c_try_cpp
2498 
2499 # ac_fn_cxx_try_cpp LINENO
2500 # ------------------------
2501 # Try to preprocess conftest.$ac_ext, and return whether this succeeded.
2502 ac_fn_cxx_try_cpp ()
2503 {
2504   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2505   if { { ac_try="$ac_cpp conftest.$ac_ext"
2506 case "(($ac_try" in
2507   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2508   *) ac_try_echo=$ac_try;;
2509 esac
2510 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2511 $as_echo "$ac_try_echo"; } >&5
2512   (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
2513   ac_status=$?
2514   if test -s conftest.err; then
2515     grep -v '^ *+' conftest.err >conftest.er1
2516     cat conftest.er1 >&5
2517     mv -f conftest.er1 conftest.err
2518   fi
2519   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2520   test $ac_status = 0; } > conftest.i && {
2521          test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
2522          test ! -s conftest.err
2523        }; then :
2524   ac_retval=0
2525 else
2526   $as_echo "$as_me: failed program was:" >&5
2527 sed 's/^/| /' conftest.$ac_ext >&5
2528 
2529     ac_retval=1
2530 fi
2531   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2532   as_fn_set_status $ac_retval
2533 
2534 } # ac_fn_cxx_try_cpp
2535 
2536 # ac_fn_c_try_link LINENO
2537 # -----------------------
2538 # Try to link conftest.$ac_ext, and return whether this succeeded.
2539 ac_fn_c_try_link ()
2540 {
2541   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2542   rm -f conftest.$ac_objext conftest$ac_exeext
2543   if { { ac_try="$ac_link"
2544 case "(($ac_try" in
2545   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2546   *) ac_try_echo=$ac_try;;
2547 esac
2548 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2549 $as_echo "$ac_try_echo"; } >&5
2550   (eval "$ac_link") 2>conftest.err
2551   ac_status=$?
2552   if test -s conftest.err; then
2553     grep -v '^ *+' conftest.err >conftest.er1
2554     cat conftest.er1 >&5
2555     mv -f conftest.er1 conftest.err
2556   fi
2557   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2558   test $ac_status = 0; } && {
2559          test -z "$ac_c_werror_flag" ||
2560          test ! -s conftest.err
2561        } && test -s conftest$ac_exeext && {
2562          test "$cross_compiling" = yes ||
2563          test -x conftest$ac_exeext
2564        }; then :
2565   ac_retval=0
2566 else
2567   $as_echo "$as_me: failed program was:" >&5
2568 sed 's/^/| /' conftest.$ac_ext >&5
2569 
2570         ac_retval=1
2571 fi
2572   # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
2573   # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
2574   # interfere with the next link command; also delete a directory that is
2575   # left behind by Apple's compiler.  We do this before executing the actions.
2576   rm -rf conftest.dSYM conftest_ipa8_conftest.oo
2577   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2578   as_fn_set_status $ac_retval
2579 
2580 } # ac_fn_c_try_link
2581 
2582 # ac_fn_cxx_check_header_mongrel LINENO HEADER VAR INCLUDES
2583 # ---------------------------------------------------------
2584 # Tests whether HEADER exists, giving a warning if it cannot be compiled using
2585 # the include files in INCLUDES and setting the cache variable VAR
2586 # accordingly.
2587 ac_fn_cxx_check_header_mongrel ()
2588 {
2589   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2590   if eval \${$3+:} false; then :
2591   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2592 $as_echo_n "checking for $2... " >&6; }
2593 if eval \${$3+:} false; then :
2594   $as_echo_n "(cached) " >&6
2595 fi
2596 eval ac_res=\$$3
2597                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2598 $as_echo "$ac_res" >&6; }
2599 else
2600   # Is the header compilable?
2601 { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
2602 $as_echo_n "checking $2 usability... " >&6; }
2603 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2604 /* end confdefs.h.  */
2605 $4
2606 #include <$2>
2607 _ACEOF
2608 if ac_fn_cxx_try_compile "$LINENO"; then :
2609   ac_header_compiler=yes
2610 else
2611   ac_header_compiler=no
2612 fi
2613 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2614 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
2615 $as_echo "$ac_header_compiler" >&6; }
2616 
2617 # Is the header present?
2618 { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
2619 $as_echo_n "checking $2 presence... " >&6; }
2620 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2621 /* end confdefs.h.  */
2622 #include <$2>
2623 _ACEOF
2624 if ac_fn_cxx_try_cpp "$LINENO"; then :
2625   ac_header_preproc=yes
2626 else
2627   ac_header_preproc=no
2628 fi
2629 rm -f conftest.err conftest.i conftest.$ac_ext
2630 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
2631 $as_echo "$ac_header_preproc" >&6; }
2632 
2633 # So?  What about this header?
2634 case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in #((
2635   yes:no: )
2636     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
2637 $as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
2638     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
2639 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
2640     ;;
2641   no:yes:* )
2642     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
2643 $as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
2644     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     check for missing prerequisite headers?" >&5
2645 $as_echo "$as_me: WARNING: $2:     check for missing prerequisite headers?" >&2;}
2646     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
2647 $as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
2648     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&5
2649 $as_echo "$as_me: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&2;}
2650     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
2651 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
2652 ( $as_echo "## ----------------------------------------- ##
2653 ## Report this to build-dev@openjdk.java.net ##
2654 ## ----------------------------------------- ##"
2655      ) | sed "s/^/$as_me: WARNING:     /" >&2
2656     ;;
2657 esac
2658   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2659 $as_echo_n "checking for $2... " >&6; }
2660 if eval \${$3+:} false; then :
2661   $as_echo_n "(cached) " >&6
2662 else
2663   eval "$3=\$ac_header_compiler"
2664 fi
2665 eval ac_res=\$$3
2666                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2667 $as_echo "$ac_res" >&6; }
2668 fi
2669   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2670 
2671 } # ac_fn_cxx_check_header_mongrel
2672 
2673 # ac_fn_cxx_try_run LINENO
2674 # ------------------------
2675 # Try to link conftest.$ac_ext, and return whether this succeeded. Assumes
2676 # that executables *can* be run.
2677 ac_fn_cxx_try_run ()
2678 {
2679   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2680   if { { ac_try="$ac_link"
2681 case "(($ac_try" in
2682   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2683   *) ac_try_echo=$ac_try;;
2684 esac
2685 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2686 $as_echo "$ac_try_echo"; } >&5
2687   (eval "$ac_link") 2>&5
2688   ac_status=$?
2689   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2690   test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'
2691   { { case "(($ac_try" in
2692   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2693   *) ac_try_echo=$ac_try;;
2694 esac
2695 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2696 $as_echo "$ac_try_echo"; } >&5
2697   (eval "$ac_try") 2>&5
2698   ac_status=$?
2699   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2700   test $ac_status = 0; }; }; then :
2701   ac_retval=0
2702 else
2703   $as_echo "$as_me: program exited with status $ac_status" >&5
2704        $as_echo "$as_me: failed program was:" >&5
2705 sed 's/^/| /' conftest.$ac_ext >&5
2706 
2707        ac_retval=$ac_status
2708 fi
2709   rm -rf conftest.dSYM conftest_ipa8_conftest.oo
2710   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2711   as_fn_set_status $ac_retval
2712 
2713 } # ac_fn_cxx_try_run
2714 
2715 # ac_fn_cxx_check_header_compile LINENO HEADER VAR INCLUDES
2716 # ---------------------------------------------------------
2717 # Tests whether HEADER exists and can be compiled using the include files in
2718 # INCLUDES, setting the cache variable VAR accordingly.
2719 ac_fn_cxx_check_header_compile ()
2720 {
2721   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2722   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2723 $as_echo_n "checking for $2... " >&6; }
2724 if eval \${$3+:} false; then :
2725   $as_echo_n "(cached) " >&6
2726 else
2727   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2728 /* end confdefs.h.  */
2729 $4
2730 #include <$2>
2731 _ACEOF
2732 if ac_fn_cxx_try_compile "$LINENO"; then :
2733   eval "$3=yes"
2734 else
2735   eval "$3=no"
2736 fi
2737 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2738 fi
2739 eval ac_res=\$$3
2740                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2741 $as_echo "$ac_res" >&6; }
2742   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2743 
2744 } # ac_fn_cxx_check_header_compile
2745 
2746 # ac_fn_cxx_compute_int LINENO EXPR VAR INCLUDES
2747 # ----------------------------------------------
2748 # Tries to find the compile-time value of EXPR in a program that includes
2749 # INCLUDES, setting VAR accordingly. Returns whether the value could be
2750 # computed
2751 ac_fn_cxx_compute_int ()
2752 {
2753   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2754   if test "$cross_compiling" = yes; then
2755     # Depending upon the size, compute the lo and hi bounds.
2756 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2757 /* end confdefs.h.  */
2758 $4
2759 int
2760 main ()
2761 {
2762 static int test_array [1 - 2 * !(($2) >= 0)];
2763 test_array [0] = 0;
2764 return test_array [0];
2765 
2766   ;
2767   return 0;
2768 }
2769 _ACEOF
2770 if ac_fn_cxx_try_compile "$LINENO"; then :
2771   ac_lo=0 ac_mid=0
2772   while :; do
2773     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2774 /* end confdefs.h.  */
2775 $4
2776 int
2777 main ()
2778 {
2779 static int test_array [1 - 2 * !(($2) <= $ac_mid)];
2780 test_array [0] = 0;
2781 return test_array [0];
2782 
2783   ;
2784   return 0;
2785 }
2786 _ACEOF
2787 if ac_fn_cxx_try_compile "$LINENO"; then :
2788   ac_hi=$ac_mid; break
2789 else
2790   as_fn_arith $ac_mid + 1 && ac_lo=$as_val
2791                         if test $ac_lo -le $ac_mid; then
2792                           ac_lo= ac_hi=
2793                           break
2794                         fi
2795                         as_fn_arith 2 '*' $ac_mid + 1 && ac_mid=$as_val
2796 fi
2797 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2798   done
2799 else
2800   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2801 /* end confdefs.h.  */
2802 $4
2803 int
2804 main ()
2805 {
2806 static int test_array [1 - 2 * !(($2) < 0)];
2807 test_array [0] = 0;
2808 return test_array [0];
2809 
2810   ;
2811   return 0;
2812 }
2813 _ACEOF
2814 if ac_fn_cxx_try_compile "$LINENO"; then :
2815   ac_hi=-1 ac_mid=-1
2816   while :; do
2817     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2818 /* end confdefs.h.  */
2819 $4
2820 int
2821 main ()
2822 {
2823 static int test_array [1 - 2 * !(($2) >= $ac_mid)];
2824 test_array [0] = 0;
2825 return test_array [0];
2826 
2827   ;
2828   return 0;
2829 }
2830 _ACEOF
2831 if ac_fn_cxx_try_compile "$LINENO"; then :
2832   ac_lo=$ac_mid; break
2833 else
2834   as_fn_arith '(' $ac_mid ')' - 1 && ac_hi=$as_val
2835                         if test $ac_mid -le $ac_hi; then
2836                           ac_lo= ac_hi=
2837                           break
2838                         fi
2839                         as_fn_arith 2 '*' $ac_mid && ac_mid=$as_val
2840 fi
2841 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2842   done
2843 else
2844   ac_lo= ac_hi=
2845 fi
2846 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2847 fi
2848 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2849 # Binary search between lo and hi bounds.
2850 while test "x$ac_lo" != "x$ac_hi"; do
2851   as_fn_arith '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo && ac_mid=$as_val
2852   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2853 /* end confdefs.h.  */
2854 $4
2855 int
2856 main ()
2857 {
2858 static int test_array [1 - 2 * !(($2) <= $ac_mid)];
2859 test_array [0] = 0;
2860 return test_array [0];
2861 
2862   ;
2863   return 0;
2864 }
2865 _ACEOF
2866 if ac_fn_cxx_try_compile "$LINENO"; then :
2867   ac_hi=$ac_mid
2868 else
2869   as_fn_arith '(' $ac_mid ')' + 1 && ac_lo=$as_val
2870 fi
2871 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2872 done
2873 case $ac_lo in #((
2874 ?*) eval "$3=\$ac_lo"; ac_retval=0 ;;
2875 '') ac_retval=1 ;;
2876 esac
2877   else
2878     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2879 /* end confdefs.h.  */
2880 $4
2881 static long int longval () { return $2; }
2882 static unsigned long int ulongval () { return $2; }
2883 #include <stdio.h>
2884 #include <stdlib.h>
2885 int
2886 main ()
2887 {
2888 
2889   FILE *f = fopen ("conftest.val", "w");
2890   if (! f)
2891     return 1;
2892   if (($2) < 0)
2893     {
2894       long int i = longval ();
2895       if (i != ($2))
2896         return 1;
2897       fprintf (f, "%ld", i);
2898     }
2899   else
2900     {
2901       unsigned long int i = ulongval ();
2902       if (i != ($2))
2903         return 1;
2904       fprintf (f, "%lu", i);
2905     }
2906   /* Do not output a trailing newline, as this causes \r\n confusion
2907      on some platforms.  */
2908   return ferror (f) || fclose (f) != 0;
2909 
2910   ;
2911   return 0;
2912 }
2913 _ACEOF
2914 if ac_fn_cxx_try_run "$LINENO"; then :
2915   echo >>conftest.val; read $3 <conftest.val; ac_retval=0
2916 else
2917   ac_retval=1
2918 fi
2919 rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
2920   conftest.$ac_objext conftest.beam conftest.$ac_ext
2921 rm -f conftest.val
2922 
2923   fi
2924   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2925   as_fn_set_status $ac_retval
2926 
2927 } # ac_fn_cxx_compute_int
2928 
2929 # ac_fn_cxx_try_link LINENO
2930 # -------------------------
2931 # Try to link conftest.$ac_ext, and return whether this succeeded.
2932 ac_fn_cxx_try_link ()
2933 {
2934   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2935   rm -f conftest.$ac_objext conftest$ac_exeext
2936   if { { ac_try="$ac_link"
2937 case "(($ac_try" in
2938   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2939   *) ac_try_echo=$ac_try;;
2940 esac
2941 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2942 $as_echo "$ac_try_echo"; } >&5
2943   (eval "$ac_link") 2>conftest.err
2944   ac_status=$?
2945   if test -s conftest.err; then
2946     grep -v '^ *+' conftest.err >conftest.er1
2947     cat conftest.er1 >&5
2948     mv -f conftest.er1 conftest.err
2949   fi
2950   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2951   test $ac_status = 0; } && {
2952          test -z "$ac_cxx_werror_flag" ||
2953          test ! -s conftest.err
2954        } && test -s conftest$ac_exeext && {
2955          test "$cross_compiling" = yes ||
2956          test -x conftest$ac_exeext
2957        }; then :
2958   ac_retval=0
2959 else
2960   $as_echo "$as_me: failed program was:" >&5
2961 sed 's/^/| /' conftest.$ac_ext >&5
2962 
2963         ac_retval=1
2964 fi
2965   # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
2966   # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
2967   # interfere with the next link command; also delete a directory that is
2968   # left behind by Apple's compiler.  We do this before executing the actions.
2969   rm -rf conftest.dSYM conftest_ipa8_conftest.oo
2970   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2971   as_fn_set_status $ac_retval
2972 
2973 } # ac_fn_cxx_try_link
2974 
2975 # ac_fn_cxx_check_func LINENO FUNC VAR
2976 # ------------------------------------
2977 # Tests whether FUNC exists, setting the cache variable VAR accordingly
2978 ac_fn_cxx_check_func ()
2979 {
2980   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2981   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2982 $as_echo_n "checking for $2... " >&6; }
2983 if eval \${$3+:} false; then :
2984   $as_echo_n "(cached) " >&6
2985 else
2986   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2987 /* end confdefs.h.  */
2988 /* Define $2 to an innocuous variant, in case <limits.h> declares $2.
2989    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
2990 #define $2 innocuous_$2
2991 
2992 /* System header to define __stub macros and hopefully few prototypes,
2993     which can conflict with char $2 (); below.
2994     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
2995     <limits.h> exists even on freestanding compilers.  */
2996 
2997 #ifdef __STDC__
2998 # include <limits.h>
2999 #else
3000 # include <assert.h>
3001 #endif
3002 
3003 #undef $2
3004 
3005 /* Override any GCC internal prototype to avoid an error.
3006    Use char because int might match the return type of a GCC
3007    builtin and then its argument prototype would still apply.  */
3008 #ifdef __cplusplus
3009 extern "C"
3010 #endif
3011 char $2 ();
3012 /* The GNU C library defines this for functions which it implements
3013     to always fail with ENOSYS.  Some functions are actually named
3014     something starting with __ and the normal name is an alias.  */
3015 #if defined __stub_$2 || defined __stub___$2
3016 choke me
3017 #endif
3018 
3019 int
3020 main ()
3021 {
3022 return $2 ();
3023   ;
3024   return 0;
3025 }
3026 _ACEOF
3027 if ac_fn_cxx_try_link "$LINENO"; then :
3028   eval "$3=yes"
3029 else
3030   eval "$3=no"
3031 fi
3032 rm -f core conftest.err conftest.$ac_objext \
3033     conftest$ac_exeext conftest.$ac_ext
3034 fi
3035 eval ac_res=\$$3
3036                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
3037 $as_echo "$ac_res" >&6; }
3038   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
3039 
3040 } # ac_fn_cxx_check_func
3041 
3042 # ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES
3043 # -------------------------------------------------------
3044 # Tests whether HEADER exists and can be compiled using the include files in
3045 # INCLUDES, setting the cache variable VAR accordingly.
3046 ac_fn_c_check_header_compile ()
3047 {
3048   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
3049   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
3050 $as_echo_n "checking for $2... " >&6; }
3051 if eval \${$3+:} false; then :
3052   $as_echo_n "(cached) " >&6
3053 else
3054   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3055 /* end confdefs.h.  */
3056 $4
3057 #include <$2>
3058 _ACEOF
3059 if ac_fn_c_try_compile "$LINENO"; then :
3060   eval "$3=yes"
3061 else
3062   eval "$3=no"
3063 fi
3064 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3065 fi
3066 eval ac_res=\$$3
3067                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
3068 $as_echo "$ac_res" >&6; }
3069   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
3070 
3071 } # ac_fn_c_check_header_compile
3072 cat >config.log <<_ACEOF
3073 This file contains any messages produced by compilers while
3074 running configure, to aid debugging if configure makes a mistake.
3075 
3076 It was created by OpenJDK $as_me jdk9, which was
3077 generated by GNU Autoconf 2.69.  Invocation command line was
3078 
3079   $ $0 $@
3080 
3081 _ACEOF
3082 exec 5>>config.log
3083 {
3084 cat <<_ASUNAME
3085 ## --------- ##
3086 ## Platform. ##
3087 ## --------- ##
3088 
3089 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
3090 uname -m = `(uname -m) 2>/dev/null || echo unknown`
3091 uname -r = `(uname -r) 2>/dev/null || echo unknown`
3092 uname -s = `(uname -s) 2>/dev/null || echo unknown`
3093 uname -v = `(uname -v) 2>/dev/null || echo unknown`
3094 
3095 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
3096 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
3097 
3098 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
3099 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
3100 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
3101 /usr/bin/hostinfo      = `(/usr/bin/hostinfo) 2>/dev/null      || echo unknown`
3102 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
3103 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
3104 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
3105 
3106 _ASUNAME
3107 
3108 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3109 for as_dir in $PATH
3110 do
3111   IFS=$as_save_IFS
3112   test -z "$as_dir" && as_dir=.
3113     $as_echo "PATH: $as_dir"
3114   done
3115 IFS=$as_save_IFS
3116 
3117 } >&5
3118 
3119 cat >&5 <<_ACEOF
3120 
3121 
3122 ## ----------- ##
3123 ## Core tests. ##
3124 ## ----------- ##
3125 
3126 _ACEOF
3127 
3128 
3129 # Keep a trace of the command line.
3130 # Strip out --no-create and --no-recursion so they do not pile up.
3131 # Strip out --silent because we don't want to record it for future runs.
3132 # Also quote any args containing shell meta-characters.
3133 # Make two passes to allow for proper duplicate-argument suppression.
3134 ac_configure_args=
3135 ac_configure_args0=
3136 ac_configure_args1=
3137 ac_must_keep_next=false
3138 for ac_pass in 1 2
3139 do
3140   for ac_arg
3141   do
3142     case $ac_arg in
3143     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
3144     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
3145     | -silent | --silent | --silen | --sile | --sil)
3146       continue ;;
3147     *\'*)
3148       ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
3149     esac
3150     case $ac_pass in
3151     1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;
3152     2)
3153       as_fn_append ac_configure_args1 " '$ac_arg'"
3154       if test $ac_must_keep_next = true; then
3155         ac_must_keep_next=false # Got value, back to normal.
3156       else
3157         case $ac_arg in
3158           *=* | --config-cache | -C | -disable-* | --disable-* \
3159           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
3160           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
3161           | -with-* | --with-* | -without-* | --without-* | --x)
3162             case "$ac_configure_args0 " in
3163               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
3164             esac
3165             ;;
3166           -* ) ac_must_keep_next=true ;;
3167         esac
3168       fi
3169       as_fn_append ac_configure_args " '$ac_arg'"
3170       ;;
3171     esac
3172   done
3173 done
3174 { ac_configure_args0=; unset ac_configure_args0;}
3175 { ac_configure_args1=; unset ac_configure_args1;}
3176 
3177 # When interrupted or exit'd, cleanup temporary files, and complete
3178 # config.log.  We remove comments because anyway the quotes in there
3179 # would cause problems or look ugly.
3180 # WARNING: Use '\'' to represent an apostrophe within the trap.
3181 # WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.
3182 trap 'exit_status=$?
3183   # Save into config.log some information that might help in debugging.
3184   {
3185     echo
3186 
3187     $as_echo "## ---------------- ##
3188 ## Cache variables. ##
3189 ## ---------------- ##"
3190     echo
3191     # The following way of writing the cache mishandles newlines in values,
3192 (
3193   for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do
3194     eval ac_val=\$$ac_var
3195     case $ac_val in #(
3196     *${as_nl}*)
3197       case $ac_var in #(
3198       *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
3199 $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
3200       esac
3201       case $ac_var in #(
3202       _ | IFS | as_nl) ;; #(
3203       BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
3204       *) { eval $ac_var=; unset $ac_var;} ;;
3205       esac ;;
3206     esac
3207   done
3208   (set) 2>&1 |
3209     case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #(
3210     *${as_nl}ac_space=\ *)
3211       sed -n \
3212         "s/'\''/'\''\\\\'\'''\''/g;
3213           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p"
3214       ;; #(
3215     *)
3216       sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
3217       ;;
3218     esac |
3219     sort
3220 )
3221     echo
3222 
3223     $as_echo "## ----------------- ##
3224 ## Output variables. ##
3225 ## ----------------- ##"
3226     echo
3227     for ac_var in $ac_subst_vars
3228     do
3229       eval ac_val=\$$ac_var
3230       case $ac_val in
3231       *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
3232       esac
3233       $as_echo "$ac_var='\''$ac_val'\''"
3234     done | sort
3235     echo
3236 
3237     if test -n "$ac_subst_files"; then
3238       $as_echo "## ------------------- ##
3239 ## File substitutions. ##
3240 ## ------------------- ##"
3241       echo
3242       for ac_var in $ac_subst_files
3243       do
3244         eval ac_val=\$$ac_var
3245         case $ac_val in
3246         *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
3247         esac
3248         $as_echo "$ac_var='\''$ac_val'\''"
3249       done | sort
3250       echo
3251     fi
3252 
3253     if test -s confdefs.h; then
3254       $as_echo "## ----------- ##
3255 ## confdefs.h. ##
3256 ## ----------- ##"
3257       echo
3258       cat confdefs.h
3259       echo
3260     fi
3261     test "$ac_signal" != 0 &&
3262       $as_echo "$as_me: caught signal $ac_signal"
3263     $as_echo "$as_me: exit $exit_status"
3264   } >&5
3265   rm -f core *.core core.conftest.* &&
3266     rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
3267     exit $exit_status
3268 ' 0
3269 for ac_signal in 1 2 13 15; do
3270   trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal
3271 done
3272 ac_signal=0
3273 
3274 # confdefs.h avoids OS command line length limits that DEFS can exceed.
3275 rm -f -r conftest* confdefs.h
3276 
3277 $as_echo "/* confdefs.h */" > confdefs.h
3278 
3279 # Predefined preprocessor variables.
3280 
3281 cat >>confdefs.h <<_ACEOF
3282 #define PACKAGE_NAME "$PACKAGE_NAME"
3283 _ACEOF
3284 
3285 cat >>confdefs.h <<_ACEOF
3286 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
3287 _ACEOF
3288 
3289 cat >>confdefs.h <<_ACEOF
3290 #define PACKAGE_VERSION "$PACKAGE_VERSION"
3291 _ACEOF
3292 
3293 cat >>confdefs.h <<_ACEOF
3294 #define PACKAGE_STRING "$PACKAGE_STRING"
3295 _ACEOF
3296 
3297 cat >>confdefs.h <<_ACEOF
3298 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
3299 _ACEOF
3300 
3301 cat >>confdefs.h <<_ACEOF
3302 #define PACKAGE_URL "$PACKAGE_URL"
3303 _ACEOF
3304 
3305 
3306 # Let the site file select an alternate cache file if it wants to.
3307 # Prefer an explicitly selected file to automatically selected ones.
3308 ac_site_file1=NONE
3309 ac_site_file2=NONE
3310 if test -n "$CONFIG_SITE"; then
3311   # We do not want a PATH search for config.site.
3312   case $CONFIG_SITE in #((
3313     -*)  ac_site_file1=./$CONFIG_SITE;;
3314     */*) ac_site_file1=$CONFIG_SITE;;
3315     *)   ac_site_file1=./$CONFIG_SITE;;
3316   esac
3317 elif test "x$prefix" != xNONE; then
3318   ac_site_file1=$prefix/share/config.site
3319   ac_site_file2=$prefix/etc/config.site
3320 else
3321   ac_site_file1=$ac_default_prefix/share/config.site
3322   ac_site_file2=$ac_default_prefix/etc/config.site
3323 fi
3324 for ac_site_file in "$ac_site_file1" "$ac_site_file2"
3325 do
3326   test "x$ac_site_file" = xNONE && continue
3327   if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then
3328     { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
3329 $as_echo "$as_me: loading site script $ac_site_file" >&6;}
3330     sed 's/^/| /' "$ac_site_file" >&5
3331     . "$ac_site_file" \
3332       || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3333 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3334 as_fn_error $? "failed to load site script $ac_site_file
3335 See \`config.log' for more details" "$LINENO" 5; }
3336   fi
3337 done
3338 
3339 if test -r "$cache_file"; then
3340   # Some versions of bash will fail to source /dev/null (special files
3341   # actually), so we avoid doing that.  DJGPP emulates it as a regular file.
3342   if test /dev/null != "$cache_file" && test -f "$cache_file"; then
3343     { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
3344 $as_echo "$as_me: loading cache $cache_file" >&6;}
3345     case $cache_file in
3346       [\\/]* | ?:[\\/]* ) . "$cache_file";;
3347       *)                      . "./$cache_file";;
3348     esac
3349   fi
3350 else
3351   { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
3352 $as_echo "$as_me: creating cache $cache_file" >&6;}
3353   >$cache_file
3354 fi
3355 
3356 # Check that the precious variables saved in the cache have kept the same
3357 # value.
3358 ac_cache_corrupted=false
3359 for ac_var in $ac_precious_vars; do
3360   eval ac_old_set=\$ac_cv_env_${ac_var}_set
3361   eval ac_new_set=\$ac_env_${ac_var}_set
3362   eval ac_old_val=\$ac_cv_env_${ac_var}_value
3363   eval ac_new_val=\$ac_env_${ac_var}_value
3364   case $ac_old_set,$ac_new_set in
3365     set,)
3366       { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
3367 $as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
3368       ac_cache_corrupted=: ;;
3369     ,set)
3370       { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5
3371 $as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
3372       ac_cache_corrupted=: ;;
3373     ,);;
3374     *)
3375       if test "x$ac_old_val" != "x$ac_new_val"; then
3376         # differences in whitespace do not lead to failure.
3377         ac_old_val_w=`echo x $ac_old_val`
3378         ac_new_val_w=`echo x $ac_new_val`
3379         if test "$ac_old_val_w" != "$ac_new_val_w"; then
3380           { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5
3381 $as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
3382           ac_cache_corrupted=:
3383         else
3384           { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
3385 $as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
3386           eval $ac_var=\$ac_old_val
3387         fi
3388         { $as_echo "$as_me:${as_lineno-$LINENO}:   former value:  \`$ac_old_val'" >&5
3389 $as_echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
3390         { $as_echo "$as_me:${as_lineno-$LINENO}:   current value: \`$ac_new_val'" >&5
3391 $as_echo "$as_me:   current value: \`$ac_new_val'" >&2;}
3392       fi;;
3393   esac
3394   # Pass precious variables to config.status.
3395   if test "$ac_new_set" = set; then
3396     case $ac_new_val in
3397     *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
3398     *) ac_arg=$ac_var=$ac_new_val ;;
3399     esac
3400     case " $ac_configure_args " in
3401       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
3402       *) as_fn_append ac_configure_args " '$ac_arg'" ;;
3403     esac
3404   fi
3405 done
3406 if $ac_cache_corrupted; then
3407   { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3408 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3409   { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
3410 $as_echo "$as_me: error: changes in the environment can compromise the build" >&2;}
3411   as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5
3412 fi
3413 ## -------------------- ##
3414 ## Main body of script. ##
3415 ## -------------------- ##
3416 
3417 ac_ext=c
3418 ac_cpp='$CPP $CPPFLAGS'
3419 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3420 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3421 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3422 
3423 
3424 
3425 ac_aux_dir=
3426 for ac_dir in $TOPDIR/common/autoconf/build-aux "$srcdir"/$TOPDIR/common/autoconf/build-aux; do
3427   if test -f "$ac_dir/install-sh"; then
3428     ac_aux_dir=$ac_dir
3429     ac_install_sh="$ac_aux_dir/install-sh -c"
3430     break
3431   elif test -f "$ac_dir/install.sh"; then
3432     ac_aux_dir=$ac_dir
3433     ac_install_sh="$ac_aux_dir/install.sh -c"
3434     break
3435   elif test -f "$ac_dir/shtool"; then
3436     ac_aux_dir=$ac_dir
3437     ac_install_sh="$ac_aux_dir/shtool install -c"
3438     break
3439   fi
3440 done
3441 if test -z "$ac_aux_dir"; then
3442   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
3443 fi
3444 
3445 # These three variables are undocumented and unsupported,
3446 # and are intended to be withdrawn in a future Autoconf release.
3447 # They can cause serious problems if a builder's source tree is in a directory
3448 # whose full name contains unusual characters.
3449 ac_config_guess="$SHELL $ac_aux_dir/config.guess"  # Please don't use this var.
3450 ac_config_sub="$SHELL $ac_aux_dir/config.sub"  # Please don't use this var.
3451 ac_configure="$SHELL $ac_aux_dir/configure"  # Please don't use this var.
3452 
3453 
3454 # pkg.m4 - Macros to locate and utilise pkg-config.            -*- Autoconf -*-
3455 
3456 #
3457 # Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
3458 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3459 #
3460 # This code is free software; you can redistribute it and/or modify it
3461 # under the terms of the GNU General Public License version 2 only, as
3462 # published by the Free Software Foundation.  Oracle designates this
3463 # particular file as subject to the "Classpath" exception as provided
3464 # by Oracle in the LICENSE file that accompanied this code.
3465 #
3466 # This code is distributed in the hope that it will be useful, but WITHOUT
3467 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3468 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3469 # version 2 for more details (a copy is included in the LICENSE file that
3470 # accompanied this code).
3471 #
3472 # You should have received a copy of the GNU General Public License version
3473 # 2 along with this work; if not, write to the Free Software Foundation,
3474 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3475 #
3476 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3477 # or visit www.oracle.com if you need additional information or have any
3478 # questions.
3479 #
3480 
3481 #
3482 # Copyright © 2004 Scott James Remnant <scott@netsplit.com>.
3483 #
3484 # This program is free software; you can redistribute it and/or modify
3485 # it under the terms of the GNU General Public License as published by
3486 # the Free Software Foundation; either version 2 of the License, or
3487 # (at your option) any later version.
3488 #
3489 # This program is distributed in the hope that it will be useful, but
3490 # WITHOUT ANY WARRANTY; without even the implied warranty of
3491 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
3492 # General Public License for more details.
3493 #
3494 # You should have received a copy of the GNU General Public License
3495 # along with this program; if not, write to the Free Software
3496 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
3497 #
3498 # As a special exception to the GNU General Public License, if you
3499 # distribute this file as part of a program that contains a
3500 # configuration script generated by Autoconf, you may include it under
3501 # the same distribution terms that you use for the rest of that program.
3502 
3503 # PKG_PROG_PKG_CONFIG([MIN-VERSION])
3504 # ----------------------------------
3505 # PKG_PROG_PKG_CONFIG
3506 
3507 # PKG_CHECK_EXISTS(MODULES, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
3508 #
3509 # Check to see whether a particular set of modules exists.  Similar
3510 # to PKG_CHECK_MODULES(), but does not set variables or print errors.
3511 #
3512 #
3513 # Similar to PKG_CHECK_MODULES, make sure that the first instance of
3514 # this or PKG_CHECK_MODULES is called, or make sure to call
3515 # PKG_CHECK_EXISTS manually
3516 # --------------------------------------------------------------
3517 
3518 
3519 
3520 # _PKG_CONFIG([VARIABLE], [COMMAND], [MODULES])
3521 # ---------------------------------------------
3522 # _PKG_CONFIG
3523 
3524 # _PKG_SHORT_ERRORS_SUPPORTED
3525 # -----------------------------
3526 # _PKG_SHORT_ERRORS_SUPPORTED
3527 
3528 
3529 # PKG_CHECK_MODULES(VARIABLE-PREFIX, MODULES, [ACTION-IF-FOUND],
3530 # [ACTION-IF-NOT-FOUND])
3531 #
3532 #
3533 # Note that if there is a possibility the first call to
3534 # PKG_CHECK_MODULES might not happen, you should be sure to include an
3535 # explicit call to PKG_PROG_PKG_CONFIG in your configure.ac
3536 #
3537 #
3538 # --------------------------------------------------------------
3539 # PKG_CHECK_MODULES
3540 
3541 
3542 # Include these first...
3543 #
3544 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
3545 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3546 #
3547 # This code is free software; you can redistribute it and/or modify it
3548 # under the terms of the GNU General Public License version 2 only, as
3549 # published by the Free Software Foundation.  Oracle designates this
3550 # particular file as subject to the "Classpath" exception as provided
3551 # by Oracle in the LICENSE file that accompanied this code.
3552 #
3553 # This code is distributed in the hope that it will be useful, but WITHOUT
3554 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3555 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3556 # version 2 for more details (a copy is included in the LICENSE file that
3557 # accompanied this code).
3558 #
3559 # You should have received a copy of the GNU General Public License version
3560 # 2 along with this work; if not, write to the Free Software Foundation,
3561 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3562 #
3563 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3564 # or visit www.oracle.com if you need additional information or have any
3565 # questions.
3566 #
3567 
3568 # Create a function/macro that takes a series of named arguments. The call is
3569 # similar to AC_DEFUN, but the setup of the function looks like this:
3570 # BASIC_DEFUN_NAMED([MYFUNC], [FOO *BAR], [$@], [
3571 # ... do something
3572 #   AC_MSG_NOTICE([Value of BAR is ARG_BAR])
3573 # ])
3574 # A star (*) in front of a named argument means that it is required and it's
3575 # presence will be verified. To pass e.g. the first value as a normal indexed
3576 # argument, use [m4_shift($@)] as the third argument instead of [$@]. These
3577 # arguments are referenced in the function by their name prefixed by ARG_, e.g.
3578 # "ARG_FOO".
3579 #
3580 # The generated function can be called like this:
3581 # MYFUNC(FOO: [foo-val],
3582 #     BAR: [
3583 #         $ECHO hello world
3584 #     ])
3585 # Note that the argument value must start on the same line as the argument name.
3586 #
3587 # Argument 1: Name of the function to define
3588 # Argument 2: List of legal named arguments, with a * prefix for required arguments
3589 # Argument 3: Argument array to treat as named, typically $@
3590 # Argument 4: The main function body
3591 
3592 
3593 # Test if $1 is a valid argument to $3 (often is $JAVA passed as $3)
3594 # If so, then append $1 to $2 \
3595 # Also set JVM_ARG_OK to true/false depending on outcome.
3596 
3597 
3598 # Appends a string to a path variable, only adding the : when needed.
3599 
3600 
3601 # Prepends a string to a path variable, only adding the : when needed.
3602 
3603 
3604 # This will make sure the given variable points to a full and proper
3605 # path. This means:
3606 # 1) There will be no spaces in the path. On unix platforms,
3607 #    spaces in the path will result in an error. On Windows,
3608 #    the path will be rewritten using short-style to be space-free.
3609 # 2) The path will be absolute, and it will be in unix-style (on
3610 #     cygwin).
3611 # $1: The name of the variable to fix
3612 
3613 
3614 # This will make sure the given variable points to a executable
3615 # with a full and proper path. This means:
3616 # 1) There will be no spaces in the path. On unix platforms,
3617 #    spaces in the path will result in an error. On Windows,
3618 #    the path will be rewritten using short-style to be space-free.
3619 # 2) The path will be absolute, and it will be in unix-style (on
3620 #     cygwin).
3621 # Any arguments given to the executable is preserved.
3622 # If the input variable does not have a directory specification, then
3623 # it need to be in the PATH.
3624 # $1: The name of the variable to fix
3625 
3626 
3627 
3628 
3629 # Register a --with argument but mark it as deprecated
3630 # $1: The name of the with argument to deprecate, not including --with-
3631 
3632 
3633 # Register a --enable argument but mark it as deprecated
3634 # $1: The name of the with argument to deprecate, not including --enable-
3635 # $2: The name of the argument to deprecate, in shell variable style (i.e. with _ instead of -)
3636 # $3: Messages to user.
3637 
3638 
3639 
3640 
3641 # Test that variable $1 denoting a program is not empty. If empty, exit with an error.
3642 # $1: variable to check
3643 
3644 
3645 # Check that there are no unprocessed overridden variables left.
3646 # If so, they are an incorrect argument and we will exit with an error.
3647 
3648 
3649 # Setup a tool for the given variable. If correctly specified by the user,
3650 # use that value, otherwise search for the tool using the supplied code snippet.
3651 # $1: variable to set
3652 # $2: code snippet to call to look for the tool
3653 # $3: code snippet to call if variable was used to find tool
3654 
3655 
3656 # Call BASIC_SETUP_TOOL with AC_PATH_PROGS to locate the tool
3657 # $1: variable to set
3658 # $2: executable name (or list of names) to look for
3659 
3660 
3661 # Call BASIC_SETUP_TOOL with AC_CHECK_TOOLS to locate the tool
3662 # $1: variable to set
3663 # $2: executable name (or list of names) to look for
3664 
3665 
3666 # Like BASIC_PATH_PROGS but fails if no tool was found.
3667 # $1: variable to set
3668 # $2: executable name (or list of names) to look for
3669 
3670 
3671 # Like BASIC_SETUP_TOOL but fails if no tool was found.
3672 # $1: variable to set
3673 # $2: autoconf macro to call to look for the special tool
3674 
3675 
3676 # Setup the most fundamental tools that relies on not much else to set up,
3677 # but is used by much of the early bootstrap code.
3678 
3679 
3680 # Setup basic configuration paths, and platform-specific stuff related to PATHs.
3681 
3682 
3683 # Evaluates platform specific overrides for devkit variables.
3684 # $1: Name of variable
3685 
3686 
3687 
3688 
3689 
3690 
3691 #%%% Simple tools %%%
3692 
3693 # Check if we have found a usable version of make
3694 # $1: the path to a potential make binary (or empty)
3695 # $2: the description on how we found this
3696 
3697 
3698 
3699 
3700 # Goes looking for a usable version of GNU make.
3701 
3702 
3703 
3704 
3705 
3706 
3707 # Check if build directory is on local disk. If not possible to determine,
3708 # we prefer to claim it's local.
3709 # Argument 1: directory to test
3710 # Argument 2: what to do if it is on local disk
3711 # Argument 3: what to do otherwise (remote disk or failure)
3712 
3713 
3714 # Check that source files have basic read permissions set. This might
3715 # not be the case in cygwin in certain conditions.
3716 
3717 
3718 
3719 
3720 # Check for support for specific options in bash
3721 
3722 
3723 ################################################################################
3724 #
3725 # Default make target
3726 #
3727 
3728 
3729 # Code to run after AC_OUTPUT
3730 
3731 
3732 #
3733 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
3734 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3735 #
3736 # This code is free software; you can redistribute it and/or modify it
3737 # under the terms of the GNU General Public License version 2 only, as
3738 # published by the Free Software Foundation.  Oracle designates this
3739 # particular file as subject to the "Classpath" exception as provided
3740 # by Oracle in the LICENSE file that accompanied this code.
3741 #
3742 # This code is distributed in the hope that it will be useful, but WITHOUT
3743 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3744 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3745 # version 2 for more details (a copy is included in the LICENSE file that
3746 # accompanied this code).
3747 #
3748 # You should have received a copy of the GNU General Public License version
3749 # 2 along with this work; if not, write to the Free Software Foundation,
3750 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3751 #
3752 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3753 # or visit www.oracle.com if you need additional information or have any
3754 # questions.
3755 #
3756 
3757 
3758 
3759 
3760 
3761 # Helper function which possibly converts a path using DOS-style short mode.
3762 # If so, the updated path is stored in $new_path.
3763 # $1: The path to check
3764 
3765 
3766 # Helper function which possibly converts a path using DOS-style short mode.
3767 # If so, the updated path is stored in $new_path.
3768 # $1: The path to check
3769 
3770 
3771 # FIXME: The BASIC_FIXUP_*_CYGWIN/MSYS is most likely too convoluted
3772 # and could probably be heavily simplified. However, all changes in this
3773 # area tend to need lot of testing in different scenarios, and in lack of
3774 # proper unit testing, cleaning this up has not been deemed worth the effort
3775 # at the moment.
3776 
3777 
3778 
3779 
3780 
3781 
3782 
3783 
3784 
3785 # Setup basic configuration paths, and platform-specific stuff related to PATHs.
3786 
3787 
3788 
3789 
3790 # ... then the rest
3791 #
3792 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
3793 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3794 #
3795 # This code is free software; you can redistribute it and/or modify it
3796 # under the terms of the GNU General Public License version 2 only, as
3797 # published by the Free Software Foundation.  Oracle designates this
3798 # particular file as subject to the "Classpath" exception as provided
3799 # by Oracle in the LICENSE file that accompanied this code.
3800 #
3801 # This code is distributed in the hope that it will be useful, but WITHOUT
3802 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3803 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3804 # version 2 for more details (a copy is included in the LICENSE file that
3805 # accompanied this code).
3806 #
3807 # You should have received a copy of the GNU General Public License version
3808 # 2 along with this work; if not, write to the Free Software Foundation,
3809 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3810 #
3811 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3812 # or visit www.oracle.com if you need additional information or have any
3813 # questions.
3814 #
3815 
3816 ########################################################################
3817 # This file handles detection of the Boot JDK. The Boot JDK detection
3818 # process has been developed as a response to solve a complex real-world
3819 # problem. Initially, it was simple, but it has grown as platform after
3820 # platform, idiosyncracy after idiosyncracy has been supported.
3821 #
3822 # The basic idea is this:
3823 # 1) You need an acceptable *) JDK to use as a Boot JDK
3824 # 2) There are several ways to locate a JDK, that are mostly platform
3825 #    dependent **)
3826 # 3) You can have multiple JDKs installed
3827 # 4) If possible, configure should try to dig out an acceptable JDK
3828 #    automatically, without having to resort to command-line options
3829 #
3830 # *)  acceptable means e.g. JDK7 for building JDK8, a complete JDK (with
3831 #     javac) and not a JRE, etc.
3832 #
3833 # **) On Windows we typically use a well-known path.
3834 #     On MacOSX we typically use the tool java_home.
3835 #     On Linux we typically find javac in the $PATH, and then follow a
3836 #     chain of symlinks that often ends up in a real JDK.
3837 #
3838 # This leads to the code where we check in different ways to locate a
3839 # JDK, and if one is found, check if it is acceptable. If not, we print
3840 # our reasons for rejecting it (useful when debugging non-working
3841 # configure situations) and continue checking the next one.
3842 ########################################################################
3843 
3844 # Execute the check given as argument, and verify the result
3845 # If the Boot JDK was previously found, do nothing
3846 # $1 A command line (typically autoconf macro) to execute
3847 
3848 
3849 # Test: Is bootjdk explicitely set by command line arguments?
3850 
3851 
3852 # Test: Is $JAVA_HOME set?
3853 
3854 
3855 # Test: Is there a java or javac in the PATH, which is a symlink to the JDK?
3856 
3857 
3858 # Test: Is there a /usr/libexec/java_home? (Typically on MacOSX)
3859 # $1: Argument to the java_home binary (optional)
3860 
3861 
3862 # Test: On MacOS X, can we find a boot jdk using /usr/libexec/java_home?
3863 
3864 
3865 # Look for a jdk in the given path. If there are multiple, try to select the newest.
3866 # If found, set BOOT_JDK and BOOT_JDK_FOUND.
3867 # $1 = Path to directory containing jdk installations.
3868 # $2 = String to append to the found JDK directory to get the proper JDK home
3869 
3870 
3871 # Call BOOTJDK_FIND_BEST_JDK_IN_DIRECTORY, but use the given
3872 # environmental variable as base for where to look.
3873 # $1 Name of an environmal variable, assumed to point to the Program Files directory.
3874 
3875 
3876 # Test: Is there a JDK installed in default, well-known locations?
3877 
3878 
3879 # Check that a command-line tool in the Boot JDK is correct
3880 # $1 = name of variable to assign
3881 # $2 = name of binary
3882 
3883 
3884 ###############################################################################
3885 #
3886 # We need a Boot JDK to bootstrap the build.
3887 #
3888 
3889 
3890 
3891 
3892 
3893 # BUILD_JDK: the location of the latest JDK that can run
3894 #   on the host system and supports the target class file version
3895 #   generated in this JDK build.  This variable should only be
3896 #   used after the launchers are built.
3897 #
3898 
3899 # Execute the check given as argument, and verify the result.
3900 # If the JDK was previously found, do nothing.
3901 # $1 A command line (typically autoconf macro) to execute
3902 
3903 
3904 # By default the BUILD_JDK is the JDK_OUTPUTDIR.  If the target architecture
3905 # is different than the host system doing the build (e.g. cross-compilation),
3906 # a special BUILD_JDK is built as part of the build process.  An external
3907 # prebuilt BUILD_JDK can also be supplied.
3908 
3909 
3910 #
3911 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
3912 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3913 #
3914 # This code is free software; you can redistribute it and/or modify it
3915 # under the terms of the GNU General Public License version 2 only, as
3916 # published by the Free Software Foundation.  Oracle designates this
3917 # particular file as subject to the "Classpath" exception as provided
3918 # by Oracle in the LICENSE file that accompanied this code.
3919 #
3920 # This code is distributed in the hope that it will be useful, but WITHOUT
3921 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3922 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3923 # version 2 for more details (a copy is included in the LICENSE file that
3924 # accompanied this code).
3925 #
3926 # You should have received a copy of the GNU General Public License version
3927 # 2 along with this work; if not, write to the Free Software Foundation,
3928 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3929 #
3930 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3931 # or visit www.oracle.com if you need additional information or have any
3932 # questions.
3933 #
3934 
3935 
3936 
3937 
3938 
3939 
3940 
3941 
3942 
3943 
3944 
3945 
3946 
3947 
3948 
3949 
3950 
3951 ################################################################################
3952 #
3953 # Runs icecc-create-env once and prints the error if it fails
3954 #
3955 # $1: arguments to icecc-create-env
3956 # $2: log file
3957 #
3958 
3959 
3960 ################################################################################
3961 #
3962 # Optionally enable distributed compilation of native code using icecc/icecream
3963 #
3964 
3965 
3966 
3967 
3968 
3969 
3970 
3971 #
3972 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
3973 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3974 #
3975 # This code is free software; you can redistribute it and/or modify it
3976 # under the terms of the GNU General Public License version 2 only, as
3977 # published by the Free Software Foundation.  Oracle designates this
3978 # particular file as subject to the "Classpath" exception as provided
3979 # by Oracle in the LICENSE file that accompanied this code.
3980 #
3981 # This code is distributed in the hope that it will be useful, but WITHOUT
3982 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3983 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3984 # version 2 for more details (a copy is included in the LICENSE file that
3985 # accompanied this code).
3986 #
3987 # You should have received a copy of the GNU General Public License version
3988 # 2 along with this work; if not, write to the Free Software Foundation,
3989 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3990 #
3991 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3992 # or visit www.oracle.com if you need additional information or have any
3993 # questions.
3994 #
3995 
3996 # Reset the global CFLAGS/LDFLAGS variables and initialize them with the
3997 # corresponding configure arguments instead
3998 
3999 
4000 # Setup the sysroot flags and add them to global CFLAGS and LDFLAGS so
4001 # that configure can use them while detecting compilers.
4002 # TOOLCHAIN_TYPE is available here.
4003 # Param 1 - Optional prefix to all variables. (e.g BUILD_)
4004 
4005 
4006 
4007 
4008 
4009 
4010 # Documentation on common flags used for solstudio in HIGHEST.
4011 #
4012 # WARNING: Use of OPTIMIZATION_LEVEL=HIGHEST in your Makefile needs to be
4013 #          done with care, there are some assumptions below that need to
4014 #          be understood about the use of pointers, and IEEE behavior.
4015 #
4016 # -fns: Use non-standard floating point mode (not IEEE 754)
4017 # -fsimple: Do some simplification of floating point arithmetic (not IEEE 754)
4018 # -fsingle: Use single precision floating point with 'float'
4019 # -xalias_level=basic: Assume memory references via basic pointer types do not alias
4020 #   (Source with excessing pointer casting and data access with mixed
4021 #    pointer types are not recommended)
4022 # -xbuiltin=%all: Use intrinsic or inline versions for math/std functions
4023 #   (If you expect perfect errno behavior, do not use this)
4024 # -xdepend: Loop data dependency optimizations (need -xO3 or higher)
4025 # -xrestrict: Pointer parameters to functions do not overlap
4026 #   (Similar to -xalias_level=basic usage, but less obvious sometimes.
4027 #    If you pass in multiple pointers to the same data, do not use this)
4028 # -xlibmil: Inline some library routines
4029 #   (If you expect perfect errno behavior, do not use this)
4030 # -xlibmopt: Use optimized math routines (CURRENTLY DISABLED)
4031 #   (If you expect perfect errno behavior, do not use this)
4032 #  Can cause undefined external on Solaris 8 X86 on __sincos, removing for now
4033 
4034     # FIXME: this will never happen since sparc != sparcv9, ie 32 bit, which we don't build anymore.
4035     # Bug?
4036     #if test "x$OPENJDK_TARGET_CPU" = xsparc; then
4037     #  CFLAGS_JDK="${CFLAGS_JDK} -xmemalign=4s"
4038     #  CXXFLAGS_JDK="${CXXFLAGS_JDK} -xmemalign=4s"
4039     #fi
4040 
4041 
4042 
4043 
4044 
4045 
4046 ################################################################################
4047 # $1 - Either BUILD or TARGET to pick the correct OS/CPU variables to check
4048 #      conditionals against.
4049 # $2 - Optional prefix for each variable defined.
4050 
4051 
4052 # FLAGS_C_COMPILER_CHECK_ARGUMENTS(ARGUMENT: [ARGUMENT], IF_TRUE: [RUN-IF-TRUE],
4053 #                                  IF_FALSE: [RUN-IF-FALSE])
4054 # ------------------------------------------------------------
4055 # Check that the C compiler supports an argument
4056 
4057 
4058 
4059 
4060 # FLAGS_CXX_COMPILER_CHECK_ARGUMENTS(ARGUMENT: [ARGUMENT], IF_TRUE: [RUN-IF-TRUE],
4061 #                                    IF_FALSE: [RUN-IF-FALSE])
4062 # ------------------------------------------------------------
4063 # Check that the C++ compiler supports an argument
4064 
4065 
4066 
4067 
4068 # FLAGS_COMPILER_CHECK_ARGUMENTS(ARGUMENT: [ARGUMENT], IF_TRUE: [RUN-IF-TRUE],
4069 #                                IF_FALSE: [RUN-IF-FALSE])
4070 # ------------------------------------------------------------
4071 # Check that the C and C++ compilers support an argument
4072 
4073 
4074 
4075 
4076 # FLAGS_LINKER_CHECK_ARGUMENTS(ARGUMENT: [ARGUMENT], IF_TRUE: [RUN-IF-TRUE],
4077 #                                   IF_FALSE: [RUN-IF-FALSE])
4078 # ------------------------------------------------------------
4079 # Check that the linker support an argument
4080 
4081 
4082 
4083 
4084 
4085 
4086 
4087 
4088 #
4089 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
4090 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4091 #
4092 # This code is free software; you can redistribute it and/or modify it
4093 # under the terms of the GNU General Public License version 2 only, as
4094 # published by the Free Software Foundation.  Oracle designates this
4095 # particular file as subject to the "Classpath" exception as provided
4096 # by Oracle in the LICENSE file that accompanied this code.
4097 #
4098 # This code is distributed in the hope that it will be useful, but WITHOUT
4099 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4100 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4101 # version 2 for more details (a copy is included in the LICENSE file that
4102 # accompanied this code).
4103 #
4104 # You should have received a copy of the GNU General Public License version
4105 # 2 along with this work; if not, write to the Free Software Foundation,
4106 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4107 #
4108 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4109 # or visit www.oracle.com if you need additional information or have any
4110 # questions.
4111 #
4112 
4113 
4114 
4115 
4116 
4117 cygwin_help() {
4118   case $1 in
4119     unzip)
4120       PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P unzip )"
4121       HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
4122       ;;
4123     zip)
4124       PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P zip )"
4125       HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
4126       ;;
4127     make)
4128       PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P make )"
4129       HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
4130       ;;
4131     freetype)
4132       HELP_MSG="
4133 The freetype library can now be build during the configure process.
4134 Download the freetype sources and unpack them into an arbitrary directory:
4135 
4136 wget http://download.savannah.gnu.org/releases/freetype/freetype-2.5.3.tar.gz
4137 tar -xzf freetype-2.5.3.tar.gz
4138 
4139 Then run configure with '--with-freetype-src=<freetype_src>'. This will
4140 automatically build the freetype library into '<freetype_src>/lib64' for 64-bit
4141 builds or into '<freetype_src>/lib32' for 32-bit builds.
4142 Afterwards you can always use '--with-freetype-include=<freetype_src>/include'
4143 and '--with-freetype-lib=<freetype_src>/lib32|64' for other builds.
4144 
4145 Alternatively you can unpack the sources like this to use the default directory:
4146 
4147 tar --one-top-level=$HOME/freetype --strip-components=1 -xzf freetype-2.5.3.tar.gz"
4148       ;;
4149   esac
4150 }
4151 
4152 msys_help() {
4153   PKGHANDLER_COMMAND=""
4154 }
4155 
4156 apt_help() {
4157   case $1 in
4158     reduced)
4159       PKGHANDLER_COMMAND="sudo apt-get install gcc-multilib g++-multilib" ;;
4160     devkit)
4161       PKGHANDLER_COMMAND="sudo apt-get install build-essential" ;;
4162     openjdk)
4163       PKGHANDLER_COMMAND="sudo apt-get install openjdk-8-jdk" ;;
4164     alsa)
4165       PKGHANDLER_COMMAND="sudo apt-get install libasound2-dev" ;;
4166     cups)
4167       PKGHANDLER_COMMAND="sudo apt-get install libcups2-dev" ;;
4168     freetype)
4169       PKGHANDLER_COMMAND="sudo apt-get install libfreetype6-dev" ;;
4170     ffi)
4171       PKGHANDLER_COMMAND="sudo apt-get install libffi-dev" ;;
4172     x11)
4173       PKGHANDLER_COMMAND="sudo apt-get install libX11-dev libxext-dev libxrender-dev libxtst-dev libxt-dev" ;;
4174     ccache)
4175       PKGHANDLER_COMMAND="sudo apt-get install ccache" ;;
4176     dtrace)
4177       PKGHANDLER_COMMAND="sudo apt-get install systemtap-sdt-dev" ;;
4178   esac
4179 }
4180 
4181 yum_help() {
4182   case $1 in
4183     devkit)
4184       PKGHANDLER_COMMAND="sudo yum groupinstall \"Development Tools\"" ;;
4185     openjdk)
4186       PKGHANDLER_COMMAND="sudo yum install java-1.8.0-openjdk-devel" ;;
4187     alsa)
4188       PKGHANDLER_COMMAND="sudo yum install alsa-lib-devel" ;;
4189     cups)
4190       PKGHANDLER_COMMAND="sudo yum install cups-devel" ;;
4191     freetype)
4192       PKGHANDLER_COMMAND="sudo yum install freetype-devel" ;;
4193     x11)
4194       PKGHANDLER_COMMAND="sudo yum install libXtst-devel libXt-devel libXrender-devel libXi-devel" ;;
4195     ccache)
4196       PKGHANDLER_COMMAND="sudo yum install ccache" ;;
4197   esac
4198 }
4199 
4200 port_help() {
4201   PKGHANDLER_COMMAND=""
4202 }
4203 
4204 pkgutil_help() {
4205   PKGHANDLER_COMMAND=""
4206 }
4207 
4208 pkgadd_help() {
4209   PKGHANDLER_COMMAND=""
4210 }
4211 
4212 # This function will check if we're called from the "configure" wrapper while
4213 # printing --help. If so, we will print out additional information that can
4214 # only be extracted within the autoconf script, and then exit. This must be
4215 # called at the very beginning in configure.ac.
4216 
4217 
4218 
4219 
4220 
4221 
4222 #
4223 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
4224 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4225 #
4226 # This code is free software; you can redistribute it and/or modify it
4227 # under the terms of the GNU General Public License version 2 only, as
4228 # published by the Free Software Foundation.  Oracle designates this
4229 # particular file as subject to the "Classpath" exception as provided
4230 # by Oracle in the LICENSE file that accompanied this code.
4231 #
4232 # This code is distributed in the hope that it will be useful, but WITHOUT
4233 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4234 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4235 # version 2 for more details (a copy is included in the LICENSE file that
4236 # accompanied this code).
4237 #
4238 # You should have received a copy of the GNU General Public License version
4239 # 2 along with this work; if not, write to the Free Software Foundation,
4240 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4241 #
4242 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4243 # or visit www.oracle.com if you need additional information or have any
4244 # questions.
4245 #
4246 
4247 # All valid JVM features, regardless of platform
4248 VALID_JVM_FEATURES="compiler1 compiler2 zero shark minimal dtrace jvmti jvmci \
4249     fprof vm-structs jni-check services management all-gcs nmt cds static-build"
4250 
4251 # All valid JVM variants
4252 VALID_JVM_VARIANTS="server client minimal core zero zeroshark custom"
4253 
4254 ###############################################################################
4255 # Check if the specified JVM variant should be built. To be used in shell if
4256 # constructs, like this:
4257 # if HOTSPOT_CHECK_JVM_VARIANT(server); then
4258 #
4259 # Only valid to use after HOTSPOT_SETUP_JVM_VARIANTS has setup variants.
4260 
4261 # Definition kept in one line to allow inlining in if statements.
4262 # Additional [] needed to keep m4 from mangling shell constructs.
4263 
4264 
4265 ###############################################################################
4266 # Check if the specified JVM features are explicitly enabled. To be used in
4267 # shell if constructs, like this:
4268 # if HOTSPOT_CHECK_JVM_FEATURE(jvmti); then
4269 #
4270 # Only valid to use after HOTSPOT_SETUP_JVM_FEATURES has setup features.
4271 
4272 # Definition kept in one line to allow inlining in if statements.
4273 # Additional [] needed to keep m4 from mangling shell constructs.
4274 
4275 
4276 ###############################################################################
4277 # Check which variants of the JVM that we want to build. Available variants are:
4278 #   server: normal interpreter, and a tiered C1/C2 compiler
4279 #   client: normal interpreter, and C1 (no C2 compiler)
4280 #   minimal: reduced form of client with optional features stripped out
4281 #   core: normal interpreter only, no compiler
4282 #   zero: C++ based interpreter only, no compiler
4283 #   zeroshark: C++ based interpreter, and a llvm-based compiler
4284 #   custom: baseline JVM with no default features
4285 #
4286 
4287 
4288 ###############################################################################
4289 # Check if dtrace should be enabled and has all prerequisites present.
4290 #
4291 
4292 
4293 ###############################################################################
4294 # Set up all JVM features for each JVM variant.
4295 #
4296 
4297 
4298 ###############################################################################
4299 # Validate JVM features once all setup is complete, including custom setup.
4300 #
4301 
4302 
4303 ###############################################################################
4304 # Support for old hotspot build. Remove once new hotspot build has proven
4305 # to work satisfactory.
4306 #
4307 
4308 
4309 #
4310 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
4311 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4312 #
4313 # This code is free software; you can redistribute it and/or modify it
4314 # under the terms of the GNU General Public License version 2 only, as
4315 # published by the Free Software Foundation.  Oracle designates this
4316 # particular file as subject to the "Classpath" exception as provided
4317 # by Oracle in the LICENSE file that accompanied this code.
4318 #
4319 # This code is distributed in the hope that it will be useful, but WITHOUT
4320 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4321 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4322 # version 2 for more details (a copy is included in the LICENSE file that
4323 # accompanied this code).
4324 #
4325 # You should have received a copy of the GNU General Public License version
4326 # 2 along with this work; if not, write to the Free Software Foundation,
4327 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4328 #
4329 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4330 # or visit www.oracle.com if you need additional information or have any
4331 # questions.
4332 #
4333 
4334 ###############################################################################
4335 # Check which variant of the JDK that we want to build.
4336 # Currently we have:
4337 #    normal:   standard edition
4338 # but the custom make system may add other variants
4339 #
4340 # Effectively the JDK variant gives a name to a specific set of
4341 # modules to compile into the JDK.
4342 
4343 
4344 ###############################################################################
4345 # Set the debug level
4346 #    release: no debug information, all optimizations, no asserts.
4347 #    optimized: no debug information, all optimizations, no asserts, HotSpot target is 'optimized'.
4348 #    fastdebug: debug information (-g), all optimizations, all asserts
4349 #    slowdebug: debug information (-g), no optimizations, all asserts
4350 
4351 
4352 ###############################################################################
4353 #
4354 # Should we build only OpenJDK even if closed sources are present?
4355 #
4356 
4357 
4358 
4359 
4360 ###############################################################################
4361 #
4362 # Enable or disable the elliptic curve crypto implementation
4363 #
4364 
4365 
4366 
4367 
4368 ################################################################################
4369 #
4370 # Gcov coverage data for hotspot
4371 #
4372 
4373 
4374 ################################################################################
4375 #
4376 # Static build support.  When enabled will generate static
4377 # libraries instead of shared libraries for all JDK libs.
4378 #
4379 
4380 
4381 ################################################################################
4382 #
4383 # jlink options.
4384 # We always keep packaged modules in JDK image.
4385 #
4386 
4387 
4388 ################################################################################
4389 #
4390 # Check if building of the jtreg failure handler should be enabled.
4391 #
4392 
4393 
4394 #
4395 # Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
4396 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4397 #
4398 # This code is free software; you can redistribute it and/or modify it
4399 # under the terms of the GNU General Public License version 2 only, as
4400 # published by the Free Software Foundation.  Oracle designates this
4401 # particular file as subject to the "Classpath" exception as provided
4402 # by Oracle in the LICENSE file that accompanied this code.
4403 #
4404 # This code is distributed in the hope that it will be useful, but WITHOUT
4405 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4406 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4407 # version 2 for more details (a copy is included in the LICENSE file that
4408 # accompanied this code).
4409 #
4410 # You should have received a copy of the GNU General Public License version
4411 # 2 along with this work; if not, write to the Free Software Foundation,
4412 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4413 #
4414 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4415 # or visit www.oracle.com if you need additional information or have any
4416 # questions.
4417 #
4418 
4419 ###############################################################################
4420 #
4421 # Setup version numbers
4422 #
4423 
4424 # Verify that a given string represents a valid version number, and assign it
4425 # to a variable.
4426 
4427 # Argument 1: the variable to assign to
4428 # Argument 2: the value given by the user
4429 
4430 
4431 
4432 
4433 #
4434 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
4435 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4436 #
4437 # This code is free software; you can redistribute it and/or modify it
4438 # under the terms of the GNU General Public License version 2 only, as
4439 # published by the Free Software Foundation.  Oracle designates this
4440 # particular file as subject to the "Classpath" exception as provided
4441 # by Oracle in the LICENSE file that accompanied this code.
4442 #
4443 # This code is distributed in the hope that it will be useful, but WITHOUT
4444 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4445 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4446 # version 2 for more details (a copy is included in the LICENSE file that
4447 # accompanied this code).
4448 #
4449 # You should have received a copy of the GNU General Public License version
4450 # 2 along with this work; if not, write to the Free Software Foundation,
4451 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4452 #
4453 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4454 # or visit www.oracle.com if you need additional information or have any
4455 # questions.
4456 #
4457 
4458 # Major library component reside in separate files.
4459 #
4460 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
4461 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4462 #
4463 # This code is free software; you can redistribute it and/or modify it
4464 # under the terms of the GNU General Public License version 2 only, as
4465 # published by the Free Software Foundation.  Oracle designates this
4466 # particular file as subject to the "Classpath" exception as provided
4467 # by Oracle in the LICENSE file that accompanied this code.
4468 #
4469 # This code is distributed in the hope that it will be useful, but WITHOUT
4470 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4471 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4472 # version 2 for more details (a copy is included in the LICENSE file that
4473 # accompanied this code).
4474 #
4475 # You should have received a copy of the GNU General Public License version
4476 # 2 along with this work; if not, write to the Free Software Foundation,
4477 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4478 #
4479 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4480 # or visit www.oracle.com if you need additional information or have any
4481 # questions.
4482 #
4483 
4484 ################################################################################
4485 # Setup alsa (Advanced Linux Sound Architecture)
4486 ################################################################################
4487 
4488 
4489 #
4490 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
4491 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4492 #
4493 # This code is free software; you can redistribute it and/or modify it
4494 # under the terms of the GNU General Public License version 2 only, as
4495 # published by the Free Software Foundation.  Oracle designates this
4496 # particular file as subject to the "Classpath" exception as provided
4497 # by Oracle in the LICENSE file that accompanied this code.
4498 #
4499 # This code is distributed in the hope that it will be useful, but WITHOUT
4500 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4501 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4502 # version 2 for more details (a copy is included in the LICENSE file that
4503 # accompanied this code).
4504 #
4505 # You should have received a copy of the GNU General Public License version
4506 # 2 along with this work; if not, write to the Free Software Foundation,
4507 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4508 #
4509 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4510 # or visit www.oracle.com if you need additional information or have any
4511 # questions.
4512 #
4513 
4514 ################################################################################
4515 # Setup bundled libraries.
4516 #
4517 # For libjpeg, giflib, libpng, lcms2 and zlib, the source is present in the
4518 # OpenJDK repository. Default is to use these libraries as bundled, but they
4519 # might be replaced by en external version by the user.
4520 ################################################################################
4521 
4522 
4523 ################################################################################
4524 # Setup libjpeg
4525 ################################################################################
4526 
4527 
4528 ################################################################################
4529 # Setup giflib
4530 ################################################################################
4531 
4532 
4533 ################################################################################
4534 # Setup libpng
4535 ################################################################################
4536 
4537 
4538 ################################################################################
4539 # Setup zlib
4540 ################################################################################
4541 
4542 
4543 ################################################################################
4544 # Setup lcms (Little CMS)
4545 ################################################################################
4546 
4547 
4548 #
4549 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
4550 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4551 #
4552 # This code is free software; you can redistribute it and/or modify it
4553 # under the terms of the GNU General Public License version 2 only, as
4554 # published by the Free Software Foundation.  Oracle designates this
4555 # particular file as subject to the "Classpath" exception as provided
4556 # by Oracle in the LICENSE file that accompanied this code.
4557 #
4558 # This code is distributed in the hope that it will be useful, but WITHOUT
4559 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4560 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4561 # version 2 for more details (a copy is included in the LICENSE file that
4562 # accompanied this code).
4563 #
4564 # You should have received a copy of the GNU General Public License version
4565 # 2 along with this work; if not, write to the Free Software Foundation,
4566 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4567 #
4568 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4569 # or visit www.oracle.com if you need additional information or have any
4570 # questions.
4571 #
4572 
4573 ################################################################################
4574 # Setup cups (Common Unix Printing System)
4575 ################################################################################
4576 
4577 
4578 #
4579 # Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
4580 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4581 #
4582 # This code is free software; you can redistribute it and/or modify it
4583 # under the terms of the GNU General Public License version 2 only, as
4584 # published by the Free Software Foundation.  Oracle designates this
4585 # particular file as subject to the "Classpath" exception as provided
4586 # by Oracle in the LICENSE file that accompanied this code.
4587 #
4588 # This code is distributed in the hope that it will be useful, but WITHOUT
4589 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4590 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4591 # version 2 for more details (a copy is included in the LICENSE file that
4592 # accompanied this code).
4593 #
4594 # You should have received a copy of the GNU General Public License version
4595 # 2 along with this work; if not, write to the Free Software Foundation,
4596 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4597 #
4598 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4599 # or visit www.oracle.com if you need additional information or have any
4600 # questions.
4601 #
4602 
4603 ################################################################################
4604 # Setup libffi (Foreign Function Interface)
4605 ################################################################################
4606 
4607 
4608 #
4609 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
4610 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4611 #
4612 # This code is free software; you can redistribute it and/or modify it
4613 # under the terms of the GNU General Public License version 2 only, as
4614 # published by the Free Software Foundation.  Oracle designates this
4615 # particular file as subject to the "Classpath" exception as provided
4616 # by Oracle in the LICENSE file that accompanied this code.
4617 #
4618 # This code is distributed in the hope that it will be useful, but WITHOUT
4619 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4620 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4621 # version 2 for more details (a copy is included in the LICENSE file that
4622 # accompanied this code).
4623 #
4624 # You should have received a copy of the GNU General Public License version
4625 # 2 along with this work; if not, write to the Free Software Foundation,
4626 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4627 #
4628 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4629 # or visit www.oracle.com if you need additional information or have any
4630 # questions.
4631 #
4632 
4633 ################################################################################
4634 # Build the freetype lib from source
4635 ################################################################################
4636 
4637 
4638 ################################################################################
4639 # Check if a potential freeype library match is correct and usable
4640 ################################################################################
4641 
4642 
4643 ################################################################################
4644 # Setup freetype (The FreeType2 font rendering library)
4645 ################################################################################
4646 
4647 
4648 #
4649 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
4650 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4651 #
4652 # This code is free software; you can redistribute it and/or modify it
4653 # under the terms of the GNU General Public License version 2 only, as
4654 # published by the Free Software Foundation.  Oracle designates this
4655 # particular file as subject to the "Classpath" exception as provided
4656 # by Oracle in the LICENSE file that accompanied this code.
4657 #
4658 # This code is distributed in the hope that it will be useful, but WITHOUT
4659 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4660 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4661 # version 2 for more details (a copy is included in the LICENSE file that
4662 # accompanied this code).
4663 #
4664 # You should have received a copy of the GNU General Public License version
4665 # 2 along with this work; if not, write to the Free Software Foundation,
4666 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4667 #
4668 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4669 # or visit www.oracle.com if you need additional information or have any
4670 # questions.
4671 #
4672 
4673 ################################################################################
4674 # Setup the standard C/C++ runtime libraries.
4675 #
4676 # Most importantly, determine if stdc++ should be linked statically or
4677 # dynamically.
4678 ################################################################################
4679 
4680 
4681 #
4682 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
4683 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4684 #
4685 # This code is free software; you can redistribute it and/or modify it
4686 # under the terms of the GNU General Public License version 2 only, as
4687 # published by the Free Software Foundation.  Oracle designates this
4688 # particular file as subject to the "Classpath" exception as provided
4689 # by Oracle in the LICENSE file that accompanied this code.
4690 #
4691 # This code is distributed in the hope that it will be useful, but WITHOUT
4692 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4693 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4694 # version 2 for more details (a copy is included in the LICENSE file that
4695 # accompanied this code).
4696 #
4697 # You should have received a copy of the GNU General Public License version
4698 # 2 along with this work; if not, write to the Free Software Foundation,
4699 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4700 #
4701 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4702 # or visit www.oracle.com if you need additional information or have any
4703 # questions.
4704 #
4705 
4706 ################################################################################
4707 # Setup X11 Windows system
4708 ################################################################################
4709 
4710 
4711 
4712 ################################################################################
4713 # Determine which libraries are needed for this configuration
4714 ################################################################################
4715 
4716 
4717 ################################################################################
4718 # Parse library options, and setup needed libraries
4719 ################################################################################
4720 
4721 
4722 ################################################################################
4723 # Setup llvm (Low-Level VM)
4724 ################################################################################
4725 
4726 
4727 ################################################################################
4728 # Setup various libraries, typically small system libraries
4729 ################################################################################
4730 
4731 
4732 #
4733 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
4734 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4735 #
4736 # This code is free software; you can redistribute it and/or modify it
4737 # under the terms of the GNU General Public License version 2 only, as
4738 # published by the Free Software Foundation.  Oracle designates this
4739 # particular file as subject to the "Classpath" exception as provided
4740 # by Oracle in the LICENSE file that accompanied this code.
4741 #
4742 # This code is distributed in the hope that it will be useful, but WITHOUT
4743 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4744 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4745 # version 2 for more details (a copy is included in the LICENSE file that
4746 # accompanied this code).
4747 #
4748 # You should have received a copy of the GNU General Public License version
4749 # 2 along with this work; if not, write to the Free Software Foundation,
4750 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4751 #
4752 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4753 # or visit www.oracle.com if you need additional information or have any
4754 # questions.
4755 #
4756 
4757 # Support macro for PLATFORM_EXTRACT_TARGET_AND_BUILD.
4758 # Converts autoconf style CPU name to OpenJDK style, into
4759 # VAR_CPU, VAR_CPU_ARCH, VAR_CPU_BITS and VAR_CPU_ENDIAN.
4760 
4761 
4762 # Support macro for PLATFORM_EXTRACT_TARGET_AND_BUILD.
4763 # Converts autoconf style OS name to OpenJDK style, into
4764 # VAR_OS, VAR_OS_TYPE and VAR_OS_ENV.
4765 
4766 
4767 # Expects $host_os $host_cpu $build_os and $build_cpu
4768 # and $with_target_bits to have been setup!
4769 #
4770 # Translate the standard triplet(quadruplet) definition
4771 # of the target/build system into OPENJDK_TARGET_OS, OPENJDK_TARGET_CPU,
4772 # OPENJDK_BUILD_OS, etc.
4773 
4774 
4775 # Check if a reduced build (32-bit on 64-bit platforms) is requested, and modify behaviour
4776 # accordingly. Must be done after setting up build and target system, but before
4777 # doing anything else with these values.
4778 
4779 
4780 # Setup the legacy variables, for controlling the old makefiles.
4781 #
4782 
4783 
4784 # $1 - Either TARGET or BUILD to setup the variables for.
4785 
4786 
4787 
4788 
4789 #%%% Build and target systems %%%
4790 
4791 
4792 
4793 
4794 # Support macro for PLATFORM_SETUP_OPENJDK_TARGET_BITS.
4795 # Add -mX to various FLAGS variables.
4796 
4797 
4798 
4799 
4800 
4801 
4802 #
4803 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
4804 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4805 #
4806 # This code is free software; you can redistribute it and/or modify it
4807 # under the terms of the GNU General Public License version 2 only, as
4808 # published by the Free Software Foundation.  Oracle designates this
4809 # particular file as subject to the "Classpath" exception as provided
4810 # by Oracle in the LICENSE file that accompanied this code.
4811 #
4812 # This code is distributed in the hope that it will be useful, but WITHOUT
4813 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4814 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4815 # version 2 for more details (a copy is included in the LICENSE file that
4816 # accompanied this code).
4817 #
4818 # You should have received a copy of the GNU General Public License version
4819 # 2 along with this work; if not, write to the Free Software Foundation,
4820 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4821 #
4822 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4823 # or visit www.oracle.com if you need additional information or have any
4824 # questions.
4825 #
4826 
4827 
4828 
4829 
4830 
4831 
4832 
4833 ################################################################################
4834 # Define a mechanism for importing extra prebuilt modules
4835 #
4836 
4837 
4838 
4839 #
4840 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
4841 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4842 #
4843 # This code is free software; you can redistribute it and/or modify it
4844 # under the terms of the GNU General Public License version 2 only, as
4845 # published by the Free Software Foundation.  Oracle designates this
4846 # particular file as subject to the "Classpath" exception as provided
4847 # by Oracle in the LICENSE file that accompanied this code.
4848 #
4849 # This code is distributed in the hope that it will be useful, but WITHOUT
4850 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4851 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4852 # version 2 for more details (a copy is included in the LICENSE file that
4853 # accompanied this code).
4854 #
4855 # You should have received a copy of the GNU General Public License version
4856 # 2 along with this work; if not, write to the Free Software Foundation,
4857 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4858 #
4859 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4860 # or visit www.oracle.com if you need additional information or have any
4861 # questions.
4862 #
4863 
4864 ########################################################################
4865 # This file is responsible for detecting, verifying and setting up the
4866 # toolchain, i.e. the compiler, linker and related utilities. It will setup
4867 # proper paths to the binaries, but it will not setup any flags.
4868 #
4869 # The binaries used is determined by the toolchain type, which is the family of
4870 # compilers and related tools that are used.
4871 ########################################################################
4872 
4873 
4874 # All valid toolchains, regardless of platform (used by help.m4)
4875 VALID_TOOLCHAINS_all="gcc clang solstudio xlc microsoft"
4876 
4877 # These toolchains are valid on different platforms
4878 VALID_TOOLCHAINS_linux="gcc clang"
4879 VALID_TOOLCHAINS_solaris="solstudio"
4880 VALID_TOOLCHAINS_macosx="gcc clang"
4881 VALID_TOOLCHAINS_aix="xlc"
4882 VALID_TOOLCHAINS_windows="microsoft"
4883 
4884 # Toolchain descriptions
4885 TOOLCHAIN_DESCRIPTION_clang="clang/LLVM"
4886 TOOLCHAIN_DESCRIPTION_gcc="GNU Compiler Collection"
4887 TOOLCHAIN_DESCRIPTION_microsoft="Microsoft Visual Studio"
4888 TOOLCHAIN_DESCRIPTION_solstudio="Oracle Solaris Studio"
4889 TOOLCHAIN_DESCRIPTION_xlc="IBM XL C/C++"
4890 
4891 # Minimum supported versions, empty means unspecified
4892 TOOLCHAIN_MINIMUM_VERSION_clang="3.2"
4893 TOOLCHAIN_MINIMUM_VERSION_gcc="4.3"
4894 TOOLCHAIN_MINIMUM_VERSION_microsoft=""
4895 TOOLCHAIN_MINIMUM_VERSION_solstudio="5.12"
4896 TOOLCHAIN_MINIMUM_VERSION_xlc=""
4897 
4898 # Prepare the system so that TOOLCHAIN_CHECK_COMPILER_VERSION can be called.
4899 # Must have CC_VERSION_NUMBER and CXX_VERSION_NUMBER.
4900 
4901 
4902 # Check if the configured compiler (C and C++) is of a specific version or
4903 # newer. TOOLCHAIN_PREPARE_FOR_VERSION_COMPARISONS must have been called before.
4904 #
4905 # Arguments:
4906 #   VERSION:   The version string to check against the found version
4907 #   IF_AT_LEAST:   block to run if the compiler is at least this version (>=)
4908 #   IF_OLDER_THAN:   block to run if the compiler is older than this version (<)
4909 
4910 
4911 
4912 
4913 # Setup a number of variables describing how native output files are
4914 # named on this platform/toolchain.
4915 
4916 
4917 # Determine which toolchain type to use, and make sure it is valid for this
4918 # platform. Setup various information about the selected toolchain.
4919 
4920 
4921 # Before we start detecting the toolchain executables, we might need some
4922 # special setup, e.g. additional paths etc.
4923 
4924 
4925 # Restore path, etc
4926 
4927 
4928 # Check if a compiler is of the toolchain type we expect, and save the version
4929 # information from it. If the compiler does not match the expected type,
4930 # this function will abort using AC_MSG_ERROR. If it matches, the version will
4931 # be stored in CC_VERSION_NUMBER/CXX_VERSION_NUMBER (as a dotted number), and
4932 # the full version string in CC_VERSION_STRING/CXX_VERSION_STRING.
4933 #
4934 # $1 = compiler to test (CC or CXX)
4935 # $2 = human readable name of compiler (C or C++)
4936 
4937 
4938 # Try to locate the given C or C++ compiler in the path, or otherwise.
4939 #
4940 # $1 = compiler to test (CC or CXX)
4941 # $2 = human readable name of compiler (C or C++)
4942 # $3 = list of compiler names to search for
4943 
4944 
4945 # Detect the core components of the toolchain, i.e. the compilers (CC and CXX),
4946 # preprocessor (CPP and CXXCPP), the linker (LD), the assembler (AS) and the
4947 # archiver (AR). Verify that the compilers are correct according to the
4948 # toolchain type.
4949 
4950 
4951 # Setup additional tools that is considered a part of the toolchain, but not the
4952 # core part. Many of these are highly platform-specific and do not exist,
4953 # and/or are not needed on all platforms.
4954 
4955 
4956 # Setup the build tools (i.e, the compiler and linker used to build programs
4957 # that should be run on the build platform, not the target platform, as a build
4958 # helper). Since the non-cross-compile case uses the normal, target compilers
4959 # for this, we can only do this after these have been setup.
4960 
4961 
4962 # Setup legacy variables that are still needed as alternative ways to refer to
4963 # parts of the toolchain.
4964 
4965 
4966 # Do some additional checks on the detected tools.
4967 
4968 
4969 # Setup the JTReg Regression Test Harness.
4970 
4971 
4972 #
4973 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
4974 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4975 #
4976 # This code is free software; you can redistribute it and/or modify it
4977 # under the terms of the GNU General Public License version 2 only, as
4978 # published by the Free Software Foundation.  Oracle designates this
4979 # particular file as subject to the "Classpath" exception as provided
4980 # by Oracle in the LICENSE file that accompanied this code.
4981 #
4982 # This code is distributed in the hope that it will be useful, but WITHOUT
4983 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4984 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4985 # version 2 for more details (a copy is included in the LICENSE file that
4986 # accompanied this code).
4987 #
4988 # You should have received a copy of the GNU General Public License version
4989 # 2 along with this work; if not, write to the Free Software Foundation,
4990 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4991 #
4992 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4993 # or visit www.oracle.com if you need additional information or have any
4994 # questions.
4995 #
4996 
4997 ################################################################################
4998 # The order of these defines the priority by which we try to find them.
4999 VALID_VS_VERSIONS="2013 2012 2010"
5000 
5001 VS_DESCRIPTION_2010="Microsoft Visual Studio 2010"
5002 VS_VERSION_INTERNAL_2010=100
5003 VS_MSVCR_2010=msvcr100.dll
5004 # We don't use msvcp on Visual Studio 2010
5005 #VS_MSVCP_2010=msvcp100.dll
5006 VS_ENVVAR_2010="VS100COMNTOOLS"
5007 VS_VS_INSTALLDIR_2010="Microsoft Visual Studio 10.0"
5008 VS_SDK_INSTALLDIR_2010="Microsoft SDKs/Windows/v7.1"
5009 VS_VS_PLATFORM_NAME_2010="v100"
5010 VS_SDK_PLATFORM_NAME_2010="Windows7.1SDK"
5011 
5012 VS_DESCRIPTION_2012="Microsoft Visual Studio 2012"
5013 VS_VERSION_INTERNAL_2012=110
5014 VS_MSVCR_2012=msvcr110.dll
5015 VS_MSVCP_2012=msvcp110.dll
5016 VS_ENVVAR_2012="VS110COMNTOOLS"
5017 VS_VS_INSTALLDIR_2012="Microsoft Visual Studio 11.0"
5018 VS_SDK_INSTALLDIR_2012=
5019 VS_VS_PLATFORM_NAME_2012="v110"
5020 VS_SDK_PLATFORM_NAME_2012=
5021 
5022 VS_DESCRIPTION_2013="Microsoft Visual Studio 2013"
5023 VS_VERSION_INTERNAL_2013=120
5024 VS_MSVCR_2013=msvcr120.dll
5025 VS_MSVCP_2013=msvcp120.dll
5026 VS_ENVVAR_2013="VS120COMNTOOLS"
5027 VS_VS_INSTALLDIR_2013="Microsoft Visual Studio 12.0"
5028 VS_SDK_INSTALLDIR_2013=
5029 VS_VS_PLATFORM_NAME_2013="v120"
5030 VS_SDK_PLATFORM_NAME_2013=
5031 
5032 ################################################################################
5033 
5034 
5035 
5036 ################################################################################
5037 
5038 
5039 
5040 ################################################################################
5041 # Finds the bat or cmd file in Visual Studio or the SDK that sets up a proper
5042 # build environment and assigns it to VS_ENV_CMD
5043 
5044 
5045 ################################################################################
5046 
5047 
5048 
5049 ################################################################################
5050 # Check if the VS env variables were setup prior to running configure.
5051 # If not, then find vcvarsall.bat and run it automatically, and integrate
5052 # the set env variables into the spec file.
5053 
5054 
5055 
5056 
5057 
5058 
5059 
5060 
5061 
5062 
5063 
5064 
5065 
5066 
5067 # This line needs to be here, verbatim, after all includes and the dummy hook
5068 # definitions. It is replaced with custom functionality when building
5069 # custom sources.
5070 #CUSTOM_AUTOCONF_INCLUDE
5071 
5072 # Do not change or remove the following line, it is needed for consistency checks:
5073 DATE_WHEN_GENERATED=1461064700
5074 
5075 ###############################################################################
5076 #
5077 # Initialization / Boot-strapping
5078 #
5079 # The bootstrapping process needs to solve the "chicken or the egg" problem,
5080 # thus it jumps back and forth, each time gaining something needed later on.
5081 #
5082 ###############################################################################
5083 
5084 # If we are requested to print additional help, do that and then exit.
5085 # This must be the very first call.
5086 
5087   if test "x$CONFIGURE_PRINT_ADDITIONAL_HELP" != x; then
5088 
5089     # Print available toolchains
5090     $PRINTF "The following toolchains are available as arguments to --with-toolchain-type.\n"
5091     $PRINTF "Which are valid to use depends on the build platform.\n"
5092     for toolchain in $VALID_TOOLCHAINS_all; do
5093       # Use indirect variable referencing
5094       toolchain_var_name=TOOLCHAIN_DESCRIPTION_$toolchain
5095       TOOLCHAIN_DESCRIPTION=${!toolchain_var_name}
5096       $PRINTF "  %-10s  %s\n" $toolchain "$TOOLCHAIN_DESCRIPTION"
5097     done
5098     $PRINTF "\n"
5099 
5100     # Print available jvm features
5101     $PRINTF "The following JVM features are available as arguments to --with-jvm-features.\n"
5102     $PRINTF "Which are valid to use depends on the target platform.\n  "
5103     $PRINTF "%s " $VALID_JVM_FEATURES
5104     $PRINTF "\n"
5105 
5106     # And now exit directly
5107     exit 0
5108   fi
5109 
5110 
5111 # Basic initialization that must happen first of all in the normal process.
5112 
5113   # Save the original command line. This is passed to us by the wrapper configure script.
5114 
5115   # Save the path variable before it gets changed
5116   ORIGINAL_PATH="$PATH"
5117 
5118   DATE_WHEN_CONFIGURED=`LANG=C date`
5119 
5120   { $as_echo "$as_me:${as_lineno-$LINENO}: Configuration created at $DATE_WHEN_CONFIGURED." >&5
5121 $as_echo "$as_me: Configuration created at $DATE_WHEN_CONFIGURED." >&6;}
5122   { $as_echo "$as_me:${as_lineno-$LINENO}: configure script generated at timestamp $DATE_WHEN_GENERATED." >&5
5123 $as_echo "$as_me: configure script generated at timestamp $DATE_WHEN_GENERATED." >&6;}
5124 
5125 
5126   # Start with tools that do not need have cross compilation support
5127   # and can be expected to be found in the default PATH. These tools are
5128   # used by configure.
5129 
5130   # First are all the simple required tools.
5131 
5132 
5133 
5134   # Publish this variable in the help.
5135 
5136 
5137   if [ -z "${BASENAME+x}" ]; then
5138     # The variable is not set by user, try to locate tool using the code snippet
5139     for ac_prog in basename
5140 do
5141   # Extract the first word of "$ac_prog", so it can be a program name with args.
5142 set dummy $ac_prog; ac_word=$2
5143 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5144 $as_echo_n "checking for $ac_word... " >&6; }
5145 if ${ac_cv_path_BASENAME+:} false; then :
5146   $as_echo_n "(cached) " >&6
5147 else
5148   case $BASENAME in
5149   [\\/]* | ?:[\\/]*)
5150   ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
5151   ;;
5152   *)
5153   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5154 for as_dir in $PATH
5155 do
5156   IFS=$as_save_IFS
5157   test -z "$as_dir" && as_dir=.
5158     for ac_exec_ext in '' $ac_executable_extensions; do
5159   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5160     ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
5161     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5162     break 2
5163   fi
5164 done
5165   done
5166 IFS=$as_save_IFS
5167 
5168   ;;
5169 esac
5170 fi
5171 BASENAME=$ac_cv_path_BASENAME
5172 if test -n "$BASENAME"; then
5173   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
5174 $as_echo "$BASENAME" >&6; }
5175 else
5176   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5177 $as_echo "no" >&6; }
5178 fi
5179 
5180 
5181   test -n "$BASENAME" && break
5182 done
5183 
5184   else
5185     # The variable is set, but is it from the command line or the environment?
5186 
5187     # Try to remove the string !BASENAME! from our list.
5188     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BASENAME!/}
5189     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5190       # If it failed, the variable was not from the command line. Ignore it,
5191       # but warn the user (except for BASH, which is always set by the calling BASH).
5192       if test "xBASENAME" != xBASH; then
5193         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BASENAME from the environment. Use command line variables instead." >&5
5194 $as_echo "$as_me: WARNING: Ignoring value of BASENAME from the environment. Use command line variables instead." >&2;}
5195       fi
5196       # Try to locate tool using the code snippet
5197       for ac_prog in basename
5198 do
5199   # Extract the first word of "$ac_prog", so it can be a program name with args.
5200 set dummy $ac_prog; ac_word=$2
5201 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5202 $as_echo_n "checking for $ac_word... " >&6; }
5203 if ${ac_cv_path_BASENAME+:} false; then :
5204   $as_echo_n "(cached) " >&6
5205 else
5206   case $BASENAME in
5207   [\\/]* | ?:[\\/]*)
5208   ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
5209   ;;
5210   *)
5211   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5212 for as_dir in $PATH
5213 do
5214   IFS=$as_save_IFS
5215   test -z "$as_dir" && as_dir=.
5216     for ac_exec_ext in '' $ac_executable_extensions; do
5217   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5218     ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
5219     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5220     break 2
5221   fi
5222 done
5223   done
5224 IFS=$as_save_IFS
5225 
5226   ;;
5227 esac
5228 fi
5229 BASENAME=$ac_cv_path_BASENAME
5230 if test -n "$BASENAME"; then
5231   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
5232 $as_echo "$BASENAME" >&6; }
5233 else
5234   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5235 $as_echo "no" >&6; }
5236 fi
5237 
5238 
5239   test -n "$BASENAME" && break
5240 done
5241 
5242     else
5243       # If it succeeded, then it was overridden by the user. We will use it
5244       # for the tool.
5245 
5246       # First remove it from the list of overridden variables, so we can test
5247       # for unknown variables in the end.
5248       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5249 
5250       # Check if we try to supply an empty value
5251       if test "x$BASENAME" = x; then
5252         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool BASENAME= (no value)" >&5
5253 $as_echo "$as_me: Setting user supplied tool BASENAME= (no value)" >&6;}
5254         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASENAME" >&5
5255 $as_echo_n "checking for BASENAME... " >&6; }
5256         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
5257 $as_echo "disabled" >&6; }
5258       else
5259         # Check if the provided tool contains a complete path.
5260         tool_specified="$BASENAME"
5261         tool_basename="${tool_specified##*/}"
5262         if test "x$tool_basename" = "x$tool_specified"; then
5263           # A command without a complete path is provided, search $PATH.
5264           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BASENAME=$tool_basename" >&5
5265 $as_echo "$as_me: Will search for user supplied tool BASENAME=$tool_basename" >&6;}
5266           # Extract the first word of "$tool_basename", so it can be a program name with args.
5267 set dummy $tool_basename; ac_word=$2
5268 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5269 $as_echo_n "checking for $ac_word... " >&6; }
5270 if ${ac_cv_path_BASENAME+:} false; then :
5271   $as_echo_n "(cached) " >&6
5272 else
5273   case $BASENAME in
5274   [\\/]* | ?:[\\/]*)
5275   ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
5276   ;;
5277   *)
5278   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5279 for as_dir in $PATH
5280 do
5281   IFS=$as_save_IFS
5282   test -z "$as_dir" && as_dir=.
5283     for ac_exec_ext in '' $ac_executable_extensions; do
5284   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5285     ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
5286     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5287     break 2
5288   fi
5289 done
5290   done
5291 IFS=$as_save_IFS
5292 
5293   ;;
5294 esac
5295 fi
5296 BASENAME=$ac_cv_path_BASENAME
5297 if test -n "$BASENAME"; then
5298   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
5299 $as_echo "$BASENAME" >&6; }
5300 else
5301   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5302 $as_echo "no" >&6; }
5303 fi
5304 
5305 
5306           if test "x$BASENAME" = x; then
5307             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5308           fi
5309         else
5310           # Otherwise we believe it is a complete path. Use it as it is.
5311           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BASENAME=$tool_specified" >&5
5312 $as_echo "$as_me: Will use user supplied tool BASENAME=$tool_specified" >&6;}
5313           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASENAME" >&5
5314 $as_echo_n "checking for BASENAME... " >&6; }
5315           if test ! -x "$tool_specified"; then
5316             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5317 $as_echo "not found" >&6; }
5318             as_fn_error $? "User supplied tool BASENAME=$tool_specified does not exist or is not executable" "$LINENO" 5
5319           fi
5320           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5321 $as_echo "$tool_specified" >&6; }
5322         fi
5323       fi
5324     fi
5325 
5326   fi
5327 
5328 
5329 
5330   if test "x$BASENAME" = x; then
5331     as_fn_error $? "Could not find required tool for BASENAME" "$LINENO" 5
5332   fi
5333 
5334 
5335 
5336 
5337 
5338   # Publish this variable in the help.
5339 
5340 
5341   if [ -z "${BASH+x}" ]; then
5342     # The variable is not set by user, try to locate tool using the code snippet
5343     for ac_prog in bash
5344 do
5345   # Extract the first word of "$ac_prog", so it can be a program name with args.
5346 set dummy $ac_prog; ac_word=$2
5347 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5348 $as_echo_n "checking for $ac_word... " >&6; }
5349 if ${ac_cv_path_BASH+:} false; then :
5350   $as_echo_n "(cached) " >&6
5351 else
5352   case $BASH in
5353   [\\/]* | ?:[\\/]*)
5354   ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
5355   ;;
5356   *)
5357   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5358 for as_dir in $PATH
5359 do
5360   IFS=$as_save_IFS
5361   test -z "$as_dir" && as_dir=.
5362     for ac_exec_ext in '' $ac_executable_extensions; do
5363   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5364     ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
5365     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5366     break 2
5367   fi
5368 done
5369   done
5370 IFS=$as_save_IFS
5371 
5372   ;;
5373 esac
5374 fi
5375 BASH=$ac_cv_path_BASH
5376 if test -n "$BASH"; then
5377   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
5378 $as_echo "$BASH" >&6; }
5379 else
5380   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5381 $as_echo "no" >&6; }
5382 fi
5383 
5384 
5385   test -n "$BASH" && break
5386 done
5387 
5388   else
5389     # The variable is set, but is it from the command line or the environment?
5390 
5391     # Try to remove the string !BASH! from our list.
5392     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BASH!/}
5393     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5394       # If it failed, the variable was not from the command line. Ignore it,
5395       # but warn the user (except for BASH, which is always set by the calling BASH).
5396       if test "xBASH" != xBASH; then
5397         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BASH from the environment. Use command line variables instead." >&5
5398 $as_echo "$as_me: WARNING: Ignoring value of BASH from the environment. Use command line variables instead." >&2;}
5399       fi
5400       # Try to locate tool using the code snippet
5401       for ac_prog in bash
5402 do
5403   # Extract the first word of "$ac_prog", so it can be a program name with args.
5404 set dummy $ac_prog; ac_word=$2
5405 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5406 $as_echo_n "checking for $ac_word... " >&6; }
5407 if ${ac_cv_path_BASH+:} false; then :
5408   $as_echo_n "(cached) " >&6
5409 else
5410   case $BASH in
5411   [\\/]* | ?:[\\/]*)
5412   ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
5413   ;;
5414   *)
5415   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5416 for as_dir in $PATH
5417 do
5418   IFS=$as_save_IFS
5419   test -z "$as_dir" && as_dir=.
5420     for ac_exec_ext in '' $ac_executable_extensions; do
5421   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5422     ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
5423     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5424     break 2
5425   fi
5426 done
5427   done
5428 IFS=$as_save_IFS
5429 
5430   ;;
5431 esac
5432 fi
5433 BASH=$ac_cv_path_BASH
5434 if test -n "$BASH"; then
5435   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
5436 $as_echo "$BASH" >&6; }
5437 else
5438   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5439 $as_echo "no" >&6; }
5440 fi
5441 
5442 
5443   test -n "$BASH" && break
5444 done
5445 
5446     else
5447       # If it succeeded, then it was overridden by the user. We will use it
5448       # for the tool.
5449 
5450       # First remove it from the list of overridden variables, so we can test
5451       # for unknown variables in the end.
5452       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5453 
5454       # Check if we try to supply an empty value
5455       if test "x$BASH" = x; then
5456         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool BASH= (no value)" >&5
5457 $as_echo "$as_me: Setting user supplied tool BASH= (no value)" >&6;}
5458         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASH" >&5
5459 $as_echo_n "checking for BASH... " >&6; }
5460         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
5461 $as_echo "disabled" >&6; }
5462       else
5463         # Check if the provided tool contains a complete path.
5464         tool_specified="$BASH"
5465         tool_basename="${tool_specified##*/}"
5466         if test "x$tool_basename" = "x$tool_specified"; then
5467           # A command without a complete path is provided, search $PATH.
5468           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BASH=$tool_basename" >&5
5469 $as_echo "$as_me: Will search for user supplied tool BASH=$tool_basename" >&6;}
5470           # Extract the first word of "$tool_basename", so it can be a program name with args.
5471 set dummy $tool_basename; ac_word=$2
5472 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5473 $as_echo_n "checking for $ac_word... " >&6; }
5474 if ${ac_cv_path_BASH+:} false; then :
5475   $as_echo_n "(cached) " >&6
5476 else
5477   case $BASH in
5478   [\\/]* | ?:[\\/]*)
5479   ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
5480   ;;
5481   *)
5482   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5483 for as_dir in $PATH
5484 do
5485   IFS=$as_save_IFS
5486   test -z "$as_dir" && as_dir=.
5487     for ac_exec_ext in '' $ac_executable_extensions; do
5488   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5489     ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
5490     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5491     break 2
5492   fi
5493 done
5494   done
5495 IFS=$as_save_IFS
5496 
5497   ;;
5498 esac
5499 fi
5500 BASH=$ac_cv_path_BASH
5501 if test -n "$BASH"; then
5502   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
5503 $as_echo "$BASH" >&6; }
5504 else
5505   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5506 $as_echo "no" >&6; }
5507 fi
5508 
5509 
5510           if test "x$BASH" = x; then
5511             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5512           fi
5513         else
5514           # Otherwise we believe it is a complete path. Use it as it is.
5515           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BASH=$tool_specified" >&5
5516 $as_echo "$as_me: Will use user supplied tool BASH=$tool_specified" >&6;}
5517           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASH" >&5
5518 $as_echo_n "checking for BASH... " >&6; }
5519           if test ! -x "$tool_specified"; then
5520             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5521 $as_echo "not found" >&6; }
5522             as_fn_error $? "User supplied tool BASH=$tool_specified does not exist or is not executable" "$LINENO" 5
5523           fi
5524           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5525 $as_echo "$tool_specified" >&6; }
5526         fi
5527       fi
5528     fi
5529 
5530   fi
5531 
5532 
5533 
5534   if test "x$BASH" = x; then
5535     as_fn_error $? "Could not find required tool for BASH" "$LINENO" 5
5536   fi
5537 
5538 
5539 
5540 
5541 
5542   # Publish this variable in the help.
5543 
5544 
5545   if [ -z "${CAT+x}" ]; then
5546     # The variable is not set by user, try to locate tool using the code snippet
5547     for ac_prog in cat
5548 do
5549   # Extract the first word of "$ac_prog", so it can be a program name with args.
5550 set dummy $ac_prog; ac_word=$2
5551 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5552 $as_echo_n "checking for $ac_word... " >&6; }
5553 if ${ac_cv_path_CAT+:} false; then :
5554   $as_echo_n "(cached) " >&6
5555 else
5556   case $CAT in
5557   [\\/]* | ?:[\\/]*)
5558   ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
5559   ;;
5560   *)
5561   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5562 for as_dir in $PATH
5563 do
5564   IFS=$as_save_IFS
5565   test -z "$as_dir" && as_dir=.
5566     for ac_exec_ext in '' $ac_executable_extensions; do
5567   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5568     ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
5569     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5570     break 2
5571   fi
5572 done
5573   done
5574 IFS=$as_save_IFS
5575 
5576   ;;
5577 esac
5578 fi
5579 CAT=$ac_cv_path_CAT
5580 if test -n "$CAT"; then
5581   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
5582 $as_echo "$CAT" >&6; }
5583 else
5584   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5585 $as_echo "no" >&6; }
5586 fi
5587 
5588 
5589   test -n "$CAT" && break
5590 done
5591 
5592   else
5593     # The variable is set, but is it from the command line or the environment?
5594 
5595     # Try to remove the string !CAT! from our list.
5596     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CAT!/}
5597     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5598       # If it failed, the variable was not from the command line. Ignore it,
5599       # but warn the user (except for BASH, which is always set by the calling BASH).
5600       if test "xCAT" != xBASH; then
5601         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CAT from the environment. Use command line variables instead." >&5
5602 $as_echo "$as_me: WARNING: Ignoring value of CAT from the environment. Use command line variables instead." >&2;}
5603       fi
5604       # Try to locate tool using the code snippet
5605       for ac_prog in cat
5606 do
5607   # Extract the first word of "$ac_prog", so it can be a program name with args.
5608 set dummy $ac_prog; ac_word=$2
5609 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5610 $as_echo_n "checking for $ac_word... " >&6; }
5611 if ${ac_cv_path_CAT+:} false; then :
5612   $as_echo_n "(cached) " >&6
5613 else
5614   case $CAT in
5615   [\\/]* | ?:[\\/]*)
5616   ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
5617   ;;
5618   *)
5619   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5620 for as_dir in $PATH
5621 do
5622   IFS=$as_save_IFS
5623   test -z "$as_dir" && as_dir=.
5624     for ac_exec_ext in '' $ac_executable_extensions; do
5625   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5626     ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
5627     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5628     break 2
5629   fi
5630 done
5631   done
5632 IFS=$as_save_IFS
5633 
5634   ;;
5635 esac
5636 fi
5637 CAT=$ac_cv_path_CAT
5638 if test -n "$CAT"; then
5639   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
5640 $as_echo "$CAT" >&6; }
5641 else
5642   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5643 $as_echo "no" >&6; }
5644 fi
5645 
5646 
5647   test -n "$CAT" && break
5648 done
5649 
5650     else
5651       # If it succeeded, then it was overridden by the user. We will use it
5652       # for the tool.
5653 
5654       # First remove it from the list of overridden variables, so we can test
5655       # for unknown variables in the end.
5656       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5657 
5658       # Check if we try to supply an empty value
5659       if test "x$CAT" = x; then
5660         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CAT= (no value)" >&5
5661 $as_echo "$as_me: Setting user supplied tool CAT= (no value)" >&6;}
5662         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CAT" >&5
5663 $as_echo_n "checking for CAT... " >&6; }
5664         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
5665 $as_echo "disabled" >&6; }
5666       else
5667         # Check if the provided tool contains a complete path.
5668         tool_specified="$CAT"
5669         tool_basename="${tool_specified##*/}"
5670         if test "x$tool_basename" = "x$tool_specified"; then
5671           # A command without a complete path is provided, search $PATH.
5672           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CAT=$tool_basename" >&5
5673 $as_echo "$as_me: Will search for user supplied tool CAT=$tool_basename" >&6;}
5674           # Extract the first word of "$tool_basename", so it can be a program name with args.
5675 set dummy $tool_basename; ac_word=$2
5676 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5677 $as_echo_n "checking for $ac_word... " >&6; }
5678 if ${ac_cv_path_CAT+:} false; then :
5679   $as_echo_n "(cached) " >&6
5680 else
5681   case $CAT in
5682   [\\/]* | ?:[\\/]*)
5683   ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
5684   ;;
5685   *)
5686   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5687 for as_dir in $PATH
5688 do
5689   IFS=$as_save_IFS
5690   test -z "$as_dir" && as_dir=.
5691     for ac_exec_ext in '' $ac_executable_extensions; do
5692   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5693     ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
5694     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5695     break 2
5696   fi
5697 done
5698   done
5699 IFS=$as_save_IFS
5700 
5701   ;;
5702 esac
5703 fi
5704 CAT=$ac_cv_path_CAT
5705 if test -n "$CAT"; then
5706   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
5707 $as_echo "$CAT" >&6; }
5708 else
5709   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5710 $as_echo "no" >&6; }
5711 fi
5712 
5713 
5714           if test "x$CAT" = x; then
5715             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5716           fi
5717         else
5718           # Otherwise we believe it is a complete path. Use it as it is.
5719           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CAT=$tool_specified" >&5
5720 $as_echo "$as_me: Will use user supplied tool CAT=$tool_specified" >&6;}
5721           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CAT" >&5
5722 $as_echo_n "checking for CAT... " >&6; }
5723           if test ! -x "$tool_specified"; then
5724             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5725 $as_echo "not found" >&6; }
5726             as_fn_error $? "User supplied tool CAT=$tool_specified does not exist or is not executable" "$LINENO" 5
5727           fi
5728           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5729 $as_echo "$tool_specified" >&6; }
5730         fi
5731       fi
5732     fi
5733 
5734   fi
5735 
5736 
5737 
5738   if test "x$CAT" = x; then
5739     as_fn_error $? "Could not find required tool for CAT" "$LINENO" 5
5740   fi
5741 
5742 
5743 
5744 
5745 
5746   # Publish this variable in the help.
5747 
5748 
5749   if [ -z "${CHMOD+x}" ]; then
5750     # The variable is not set by user, try to locate tool using the code snippet
5751     for ac_prog in chmod
5752 do
5753   # Extract the first word of "$ac_prog", so it can be a program name with args.
5754 set dummy $ac_prog; ac_word=$2
5755 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5756 $as_echo_n "checking for $ac_word... " >&6; }
5757 if ${ac_cv_path_CHMOD+:} false; then :
5758   $as_echo_n "(cached) " >&6
5759 else
5760   case $CHMOD in
5761   [\\/]* | ?:[\\/]*)
5762   ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
5763   ;;
5764   *)
5765   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5766 for as_dir in $PATH
5767 do
5768   IFS=$as_save_IFS
5769   test -z "$as_dir" && as_dir=.
5770     for ac_exec_ext in '' $ac_executable_extensions; do
5771   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5772     ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
5773     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5774     break 2
5775   fi
5776 done
5777   done
5778 IFS=$as_save_IFS
5779 
5780   ;;
5781 esac
5782 fi
5783 CHMOD=$ac_cv_path_CHMOD
5784 if test -n "$CHMOD"; then
5785   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
5786 $as_echo "$CHMOD" >&6; }
5787 else
5788   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5789 $as_echo "no" >&6; }
5790 fi
5791 
5792 
5793   test -n "$CHMOD" && break
5794 done
5795 
5796   else
5797     # The variable is set, but is it from the command line or the environment?
5798 
5799     # Try to remove the string !CHMOD! from our list.
5800     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CHMOD!/}
5801     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5802       # If it failed, the variable was not from the command line. Ignore it,
5803       # but warn the user (except for BASH, which is always set by the calling BASH).
5804       if test "xCHMOD" != xBASH; then
5805         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CHMOD from the environment. Use command line variables instead." >&5
5806 $as_echo "$as_me: WARNING: Ignoring value of CHMOD from the environment. Use command line variables instead." >&2;}
5807       fi
5808       # Try to locate tool using the code snippet
5809       for ac_prog in chmod
5810 do
5811   # Extract the first word of "$ac_prog", so it can be a program name with args.
5812 set dummy $ac_prog; ac_word=$2
5813 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5814 $as_echo_n "checking for $ac_word... " >&6; }
5815 if ${ac_cv_path_CHMOD+:} false; then :
5816   $as_echo_n "(cached) " >&6
5817 else
5818   case $CHMOD in
5819   [\\/]* | ?:[\\/]*)
5820   ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
5821   ;;
5822   *)
5823   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5824 for as_dir in $PATH
5825 do
5826   IFS=$as_save_IFS
5827   test -z "$as_dir" && as_dir=.
5828     for ac_exec_ext in '' $ac_executable_extensions; do
5829   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5830     ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
5831     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5832     break 2
5833   fi
5834 done
5835   done
5836 IFS=$as_save_IFS
5837 
5838   ;;
5839 esac
5840 fi
5841 CHMOD=$ac_cv_path_CHMOD
5842 if test -n "$CHMOD"; then
5843   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
5844 $as_echo "$CHMOD" >&6; }
5845 else
5846   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5847 $as_echo "no" >&6; }
5848 fi
5849 
5850 
5851   test -n "$CHMOD" && break
5852 done
5853 
5854     else
5855       # If it succeeded, then it was overridden by the user. We will use it
5856       # for the tool.
5857 
5858       # First remove it from the list of overridden variables, so we can test
5859       # for unknown variables in the end.
5860       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5861 
5862       # Check if we try to supply an empty value
5863       if test "x$CHMOD" = x; then
5864         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CHMOD= (no value)" >&5
5865 $as_echo "$as_me: Setting user supplied tool CHMOD= (no value)" >&6;}
5866         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CHMOD" >&5
5867 $as_echo_n "checking for CHMOD... " >&6; }
5868         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
5869 $as_echo "disabled" >&6; }
5870       else
5871         # Check if the provided tool contains a complete path.
5872         tool_specified="$CHMOD"
5873         tool_basename="${tool_specified##*/}"
5874         if test "x$tool_basename" = "x$tool_specified"; then
5875           # A command without a complete path is provided, search $PATH.
5876           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CHMOD=$tool_basename" >&5
5877 $as_echo "$as_me: Will search for user supplied tool CHMOD=$tool_basename" >&6;}
5878           # Extract the first word of "$tool_basename", so it can be a program name with args.
5879 set dummy $tool_basename; ac_word=$2
5880 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5881 $as_echo_n "checking for $ac_word... " >&6; }
5882 if ${ac_cv_path_CHMOD+:} false; then :
5883   $as_echo_n "(cached) " >&6
5884 else
5885   case $CHMOD in
5886   [\\/]* | ?:[\\/]*)
5887   ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
5888   ;;
5889   *)
5890   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5891 for as_dir in $PATH
5892 do
5893   IFS=$as_save_IFS
5894   test -z "$as_dir" && as_dir=.
5895     for ac_exec_ext in '' $ac_executable_extensions; do
5896   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5897     ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
5898     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5899     break 2
5900   fi
5901 done
5902   done
5903 IFS=$as_save_IFS
5904 
5905   ;;
5906 esac
5907 fi
5908 CHMOD=$ac_cv_path_CHMOD
5909 if test -n "$CHMOD"; then
5910   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
5911 $as_echo "$CHMOD" >&6; }
5912 else
5913   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5914 $as_echo "no" >&6; }
5915 fi
5916 
5917 
5918           if test "x$CHMOD" = x; then
5919             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5920           fi
5921         else
5922           # Otherwise we believe it is a complete path. Use it as it is.
5923           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CHMOD=$tool_specified" >&5
5924 $as_echo "$as_me: Will use user supplied tool CHMOD=$tool_specified" >&6;}
5925           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CHMOD" >&5
5926 $as_echo_n "checking for CHMOD... " >&6; }
5927           if test ! -x "$tool_specified"; then
5928             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5929 $as_echo "not found" >&6; }
5930             as_fn_error $? "User supplied tool CHMOD=$tool_specified does not exist or is not executable" "$LINENO" 5
5931           fi
5932           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5933 $as_echo "$tool_specified" >&6; }
5934         fi
5935       fi
5936     fi
5937 
5938   fi
5939 
5940 
5941 
5942   if test "x$CHMOD" = x; then
5943     as_fn_error $? "Could not find required tool for CHMOD" "$LINENO" 5
5944   fi
5945 
5946 
5947 
5948 
5949 
5950   # Publish this variable in the help.
5951 
5952 
5953   if [ -z "${CMP+x}" ]; then
5954     # The variable is not set by user, try to locate tool using the code snippet
5955     for ac_prog in cmp
5956 do
5957   # Extract the first word of "$ac_prog", so it can be a program name with args.
5958 set dummy $ac_prog; ac_word=$2
5959 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5960 $as_echo_n "checking for $ac_word... " >&6; }
5961 if ${ac_cv_path_CMP+:} false; then :
5962   $as_echo_n "(cached) " >&6
5963 else
5964   case $CMP in
5965   [\\/]* | ?:[\\/]*)
5966   ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
5967   ;;
5968   *)
5969   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5970 for as_dir in $PATH
5971 do
5972   IFS=$as_save_IFS
5973   test -z "$as_dir" && as_dir=.
5974     for ac_exec_ext in '' $ac_executable_extensions; do
5975   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5976     ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
5977     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5978     break 2
5979   fi
5980 done
5981   done
5982 IFS=$as_save_IFS
5983 
5984   ;;
5985 esac
5986 fi
5987 CMP=$ac_cv_path_CMP
5988 if test -n "$CMP"; then
5989   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
5990 $as_echo "$CMP" >&6; }
5991 else
5992   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5993 $as_echo "no" >&6; }
5994 fi
5995 
5996 
5997   test -n "$CMP" && break
5998 done
5999 
6000   else
6001     # The variable is set, but is it from the command line or the environment?
6002 
6003     # Try to remove the string !CMP! from our list.
6004     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CMP!/}
6005     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6006       # If it failed, the variable was not from the command line. Ignore it,
6007       # but warn the user (except for BASH, which is always set by the calling BASH).
6008       if test "xCMP" != xBASH; then
6009         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CMP from the environment. Use command line variables instead." >&5
6010 $as_echo "$as_me: WARNING: Ignoring value of CMP from the environment. Use command line variables instead." >&2;}
6011       fi
6012       # Try to locate tool using the code snippet
6013       for ac_prog in cmp
6014 do
6015   # Extract the first word of "$ac_prog", so it can be a program name with args.
6016 set dummy $ac_prog; ac_word=$2
6017 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6018 $as_echo_n "checking for $ac_word... " >&6; }
6019 if ${ac_cv_path_CMP+:} false; then :
6020   $as_echo_n "(cached) " >&6
6021 else
6022   case $CMP in
6023   [\\/]* | ?:[\\/]*)
6024   ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
6025   ;;
6026   *)
6027   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6028 for as_dir in $PATH
6029 do
6030   IFS=$as_save_IFS
6031   test -z "$as_dir" && as_dir=.
6032     for ac_exec_ext in '' $ac_executable_extensions; do
6033   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6034     ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
6035     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6036     break 2
6037   fi
6038 done
6039   done
6040 IFS=$as_save_IFS
6041 
6042   ;;
6043 esac
6044 fi
6045 CMP=$ac_cv_path_CMP
6046 if test -n "$CMP"; then
6047   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
6048 $as_echo "$CMP" >&6; }
6049 else
6050   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6051 $as_echo "no" >&6; }
6052 fi
6053 
6054 
6055   test -n "$CMP" && break
6056 done
6057 
6058     else
6059       # If it succeeded, then it was overridden by the user. We will use it
6060       # for the tool.
6061 
6062       # First remove it from the list of overridden variables, so we can test
6063       # for unknown variables in the end.
6064       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6065 
6066       # Check if we try to supply an empty value
6067       if test "x$CMP" = x; then
6068         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CMP= (no value)" >&5
6069 $as_echo "$as_me: Setting user supplied tool CMP= (no value)" >&6;}
6070         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CMP" >&5
6071 $as_echo_n "checking for CMP... " >&6; }
6072         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
6073 $as_echo "disabled" >&6; }
6074       else
6075         # Check if the provided tool contains a complete path.
6076         tool_specified="$CMP"
6077         tool_basename="${tool_specified##*/}"
6078         if test "x$tool_basename" = "x$tool_specified"; then
6079           # A command without a complete path is provided, search $PATH.
6080           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CMP=$tool_basename" >&5
6081 $as_echo "$as_me: Will search for user supplied tool CMP=$tool_basename" >&6;}
6082           # Extract the first word of "$tool_basename", so it can be a program name with args.
6083 set dummy $tool_basename; ac_word=$2
6084 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6085 $as_echo_n "checking for $ac_word... " >&6; }
6086 if ${ac_cv_path_CMP+:} false; then :
6087   $as_echo_n "(cached) " >&6
6088 else
6089   case $CMP in
6090   [\\/]* | ?:[\\/]*)
6091   ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
6092   ;;
6093   *)
6094   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6095 for as_dir in $PATH
6096 do
6097   IFS=$as_save_IFS
6098   test -z "$as_dir" && as_dir=.
6099     for ac_exec_ext in '' $ac_executable_extensions; do
6100   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6101     ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
6102     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6103     break 2
6104   fi
6105 done
6106   done
6107 IFS=$as_save_IFS
6108 
6109   ;;
6110 esac
6111 fi
6112 CMP=$ac_cv_path_CMP
6113 if test -n "$CMP"; then
6114   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
6115 $as_echo "$CMP" >&6; }
6116 else
6117   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6118 $as_echo "no" >&6; }
6119 fi
6120 
6121 
6122           if test "x$CMP" = x; then
6123             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6124           fi
6125         else
6126           # Otherwise we believe it is a complete path. Use it as it is.
6127           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CMP=$tool_specified" >&5
6128 $as_echo "$as_me: Will use user supplied tool CMP=$tool_specified" >&6;}
6129           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CMP" >&5
6130 $as_echo_n "checking for CMP... " >&6; }
6131           if test ! -x "$tool_specified"; then
6132             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6133 $as_echo "not found" >&6; }
6134             as_fn_error $? "User supplied tool CMP=$tool_specified does not exist or is not executable" "$LINENO" 5
6135           fi
6136           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6137 $as_echo "$tool_specified" >&6; }
6138         fi
6139       fi
6140     fi
6141 
6142   fi
6143 
6144 
6145 
6146   if test "x$CMP" = x; then
6147     as_fn_error $? "Could not find required tool for CMP" "$LINENO" 5
6148   fi
6149 
6150 
6151 
6152 
6153 
6154   # Publish this variable in the help.
6155 
6156 
6157   if [ -z "${COMM+x}" ]; then
6158     # The variable is not set by user, try to locate tool using the code snippet
6159     for ac_prog in comm
6160 do
6161   # Extract the first word of "$ac_prog", so it can be a program name with args.
6162 set dummy $ac_prog; ac_word=$2
6163 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6164 $as_echo_n "checking for $ac_word... " >&6; }
6165 if ${ac_cv_path_COMM+:} false; then :
6166   $as_echo_n "(cached) " >&6
6167 else
6168   case $COMM in
6169   [\\/]* | ?:[\\/]*)
6170   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
6171   ;;
6172   *)
6173   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6174 for as_dir in $PATH
6175 do
6176   IFS=$as_save_IFS
6177   test -z "$as_dir" && as_dir=.
6178     for ac_exec_ext in '' $ac_executable_extensions; do
6179   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6180     ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
6181     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6182     break 2
6183   fi
6184 done
6185   done
6186 IFS=$as_save_IFS
6187 
6188   ;;
6189 esac
6190 fi
6191 COMM=$ac_cv_path_COMM
6192 if test -n "$COMM"; then
6193   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
6194 $as_echo "$COMM" >&6; }
6195 else
6196   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6197 $as_echo "no" >&6; }
6198 fi
6199 
6200 
6201   test -n "$COMM" && break
6202 done
6203 
6204   else
6205     # The variable is set, but is it from the command line or the environment?
6206 
6207     # Try to remove the string !COMM! from our list.
6208     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!COMM!/}
6209     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6210       # If it failed, the variable was not from the command line. Ignore it,
6211       # but warn the user (except for BASH, which is always set by the calling BASH).
6212       if test "xCOMM" != xBASH; then
6213         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&5
6214 $as_echo "$as_me: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&2;}
6215       fi
6216       # Try to locate tool using the code snippet
6217       for ac_prog in comm
6218 do
6219   # Extract the first word of "$ac_prog", so it can be a program name with args.
6220 set dummy $ac_prog; ac_word=$2
6221 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6222 $as_echo_n "checking for $ac_word... " >&6; }
6223 if ${ac_cv_path_COMM+:} false; then :
6224   $as_echo_n "(cached) " >&6
6225 else
6226   case $COMM in
6227   [\\/]* | ?:[\\/]*)
6228   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
6229   ;;
6230   *)
6231   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6232 for as_dir in $PATH
6233 do
6234   IFS=$as_save_IFS
6235   test -z "$as_dir" && as_dir=.
6236     for ac_exec_ext in '' $ac_executable_extensions; do
6237   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6238     ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
6239     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6240     break 2
6241   fi
6242 done
6243   done
6244 IFS=$as_save_IFS
6245 
6246   ;;
6247 esac
6248 fi
6249 COMM=$ac_cv_path_COMM
6250 if test -n "$COMM"; then
6251   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
6252 $as_echo "$COMM" >&6; }
6253 else
6254   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6255 $as_echo "no" >&6; }
6256 fi
6257 
6258 
6259   test -n "$COMM" && break
6260 done
6261 
6262     else
6263       # If it succeeded, then it was overridden by the user. We will use it
6264       # for the tool.
6265 
6266       # First remove it from the list of overridden variables, so we can test
6267       # for unknown variables in the end.
6268       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6269 
6270       # Check if we try to supply an empty value
6271       if test "x$COMM" = x; then
6272         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool COMM= (no value)" >&5
6273 $as_echo "$as_me: Setting user supplied tool COMM= (no value)" >&6;}
6274         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for COMM" >&5
6275 $as_echo_n "checking for COMM... " >&6; }
6276         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
6277 $as_echo "disabled" >&6; }
6278       else
6279         # Check if the provided tool contains a complete path.
6280         tool_specified="$COMM"
6281         tool_basename="${tool_specified##*/}"
6282         if test "x$tool_basename" = "x$tool_specified"; then
6283           # A command without a complete path is provided, search $PATH.
6284           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool COMM=$tool_basename" >&5
6285 $as_echo "$as_me: Will search for user supplied tool COMM=$tool_basename" >&6;}
6286           # Extract the first word of "$tool_basename", so it can be a program name with args.
6287 set dummy $tool_basename; ac_word=$2
6288 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6289 $as_echo_n "checking for $ac_word... " >&6; }
6290 if ${ac_cv_path_COMM+:} false; then :
6291   $as_echo_n "(cached) " >&6
6292 else
6293   case $COMM in
6294   [\\/]* | ?:[\\/]*)
6295   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
6296   ;;
6297   *)
6298   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6299 for as_dir in $PATH
6300 do
6301   IFS=$as_save_IFS
6302   test -z "$as_dir" && as_dir=.
6303     for ac_exec_ext in '' $ac_executable_extensions; do
6304   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6305     ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
6306     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6307     break 2
6308   fi
6309 done
6310   done
6311 IFS=$as_save_IFS
6312 
6313   ;;
6314 esac
6315 fi
6316 COMM=$ac_cv_path_COMM
6317 if test -n "$COMM"; then
6318   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
6319 $as_echo "$COMM" >&6; }
6320 else
6321   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6322 $as_echo "no" >&6; }
6323 fi
6324 
6325 
6326           if test "x$COMM" = x; then
6327             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6328           fi
6329         else
6330           # Otherwise we believe it is a complete path. Use it as it is.
6331           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool COMM=$tool_specified" >&5
6332 $as_echo "$as_me: Will use user supplied tool COMM=$tool_specified" >&6;}
6333           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for COMM" >&5
6334 $as_echo_n "checking for COMM... " >&6; }
6335           if test ! -x "$tool_specified"; then
6336             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6337 $as_echo "not found" >&6; }
6338             as_fn_error $? "User supplied tool COMM=$tool_specified does not exist or is not executable" "$LINENO" 5
6339           fi
6340           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6341 $as_echo "$tool_specified" >&6; }
6342         fi
6343       fi
6344     fi
6345 
6346   fi
6347 
6348 
6349 
6350   if test "x$COMM" = x; then
6351     as_fn_error $? "Could not find required tool for COMM" "$LINENO" 5
6352   fi
6353 
6354 
6355 
6356 
6357 
6358   # Publish this variable in the help.
6359 
6360 
6361   if [ -z "${CP+x}" ]; then
6362     # The variable is not set by user, try to locate tool using the code snippet
6363     for ac_prog in cp
6364 do
6365   # Extract the first word of "$ac_prog", so it can be a program name with args.
6366 set dummy $ac_prog; ac_word=$2
6367 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6368 $as_echo_n "checking for $ac_word... " >&6; }
6369 if ${ac_cv_path_CP+:} false; then :
6370   $as_echo_n "(cached) " >&6
6371 else
6372   case $CP in
6373   [\\/]* | ?:[\\/]*)
6374   ac_cv_path_CP="$CP" # Let the user override the test with a path.
6375   ;;
6376   *)
6377   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6378 for as_dir in $PATH
6379 do
6380   IFS=$as_save_IFS
6381   test -z "$as_dir" && as_dir=.
6382     for ac_exec_ext in '' $ac_executable_extensions; do
6383   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6384     ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
6385     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6386     break 2
6387   fi
6388 done
6389   done
6390 IFS=$as_save_IFS
6391 
6392   ;;
6393 esac
6394 fi
6395 CP=$ac_cv_path_CP
6396 if test -n "$CP"; then
6397   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
6398 $as_echo "$CP" >&6; }
6399 else
6400   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6401 $as_echo "no" >&6; }
6402 fi
6403 
6404 
6405   test -n "$CP" && break
6406 done
6407 
6408   else
6409     # The variable is set, but is it from the command line or the environment?
6410 
6411     # Try to remove the string !CP! from our list.
6412     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CP!/}
6413     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6414       # If it failed, the variable was not from the command line. Ignore it,
6415       # but warn the user (except for BASH, which is always set by the calling BASH).
6416       if test "xCP" != xBASH; then
6417         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CP from the environment. Use command line variables instead." >&5
6418 $as_echo "$as_me: WARNING: Ignoring value of CP from the environment. Use command line variables instead." >&2;}
6419       fi
6420       # Try to locate tool using the code snippet
6421       for ac_prog in cp
6422 do
6423   # Extract the first word of "$ac_prog", so it can be a program name with args.
6424 set dummy $ac_prog; ac_word=$2
6425 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6426 $as_echo_n "checking for $ac_word... " >&6; }
6427 if ${ac_cv_path_CP+:} false; then :
6428   $as_echo_n "(cached) " >&6
6429 else
6430   case $CP in
6431   [\\/]* | ?:[\\/]*)
6432   ac_cv_path_CP="$CP" # Let the user override the test with a path.
6433   ;;
6434   *)
6435   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6436 for as_dir in $PATH
6437 do
6438   IFS=$as_save_IFS
6439   test -z "$as_dir" && as_dir=.
6440     for ac_exec_ext in '' $ac_executable_extensions; do
6441   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6442     ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
6443     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6444     break 2
6445   fi
6446 done
6447   done
6448 IFS=$as_save_IFS
6449 
6450   ;;
6451 esac
6452 fi
6453 CP=$ac_cv_path_CP
6454 if test -n "$CP"; then
6455   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
6456 $as_echo "$CP" >&6; }
6457 else
6458   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6459 $as_echo "no" >&6; }
6460 fi
6461 
6462 
6463   test -n "$CP" && break
6464 done
6465 
6466     else
6467       # If it succeeded, then it was overridden by the user. We will use it
6468       # for the tool.
6469 
6470       # First remove it from the list of overridden variables, so we can test
6471       # for unknown variables in the end.
6472       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6473 
6474       # Check if we try to supply an empty value
6475       if test "x$CP" = x; then
6476         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CP= (no value)" >&5
6477 $as_echo "$as_me: Setting user supplied tool CP= (no value)" >&6;}
6478         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CP" >&5
6479 $as_echo_n "checking for CP... " >&6; }
6480         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
6481 $as_echo "disabled" >&6; }
6482       else
6483         # Check if the provided tool contains a complete path.
6484         tool_specified="$CP"
6485         tool_basename="${tool_specified##*/}"
6486         if test "x$tool_basename" = "x$tool_specified"; then
6487           # A command without a complete path is provided, search $PATH.
6488           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CP=$tool_basename" >&5
6489 $as_echo "$as_me: Will search for user supplied tool CP=$tool_basename" >&6;}
6490           # Extract the first word of "$tool_basename", so it can be a program name with args.
6491 set dummy $tool_basename; ac_word=$2
6492 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6493 $as_echo_n "checking for $ac_word... " >&6; }
6494 if ${ac_cv_path_CP+:} false; then :
6495   $as_echo_n "(cached) " >&6
6496 else
6497   case $CP in
6498   [\\/]* | ?:[\\/]*)
6499   ac_cv_path_CP="$CP" # Let the user override the test with a path.
6500   ;;
6501   *)
6502   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6503 for as_dir in $PATH
6504 do
6505   IFS=$as_save_IFS
6506   test -z "$as_dir" && as_dir=.
6507     for ac_exec_ext in '' $ac_executable_extensions; do
6508   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6509     ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
6510     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6511     break 2
6512   fi
6513 done
6514   done
6515 IFS=$as_save_IFS
6516 
6517   ;;
6518 esac
6519 fi
6520 CP=$ac_cv_path_CP
6521 if test -n "$CP"; then
6522   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
6523 $as_echo "$CP" >&6; }
6524 else
6525   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6526 $as_echo "no" >&6; }
6527 fi
6528 
6529 
6530           if test "x$CP" = x; then
6531             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6532           fi
6533         else
6534           # Otherwise we believe it is a complete path. Use it as it is.
6535           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CP=$tool_specified" >&5
6536 $as_echo "$as_me: Will use user supplied tool CP=$tool_specified" >&6;}
6537           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CP" >&5
6538 $as_echo_n "checking for CP... " >&6; }
6539           if test ! -x "$tool_specified"; then
6540             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6541 $as_echo "not found" >&6; }
6542             as_fn_error $? "User supplied tool CP=$tool_specified does not exist or is not executable" "$LINENO" 5
6543           fi
6544           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6545 $as_echo "$tool_specified" >&6; }
6546         fi
6547       fi
6548     fi
6549 
6550   fi
6551 
6552 
6553 
6554   if test "x$CP" = x; then
6555     as_fn_error $? "Could not find required tool for CP" "$LINENO" 5
6556   fi
6557 
6558 
6559 
6560 
6561 
6562   # Publish this variable in the help.
6563 
6564 
6565   if [ -z "${CUT+x}" ]; then
6566     # The variable is not set by user, try to locate tool using the code snippet
6567     for ac_prog in cut
6568 do
6569   # Extract the first word of "$ac_prog", so it can be a program name with args.
6570 set dummy $ac_prog; ac_word=$2
6571 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6572 $as_echo_n "checking for $ac_word... " >&6; }
6573 if ${ac_cv_path_CUT+:} false; then :
6574   $as_echo_n "(cached) " >&6
6575 else
6576   case $CUT in
6577   [\\/]* | ?:[\\/]*)
6578   ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
6579   ;;
6580   *)
6581   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6582 for as_dir in $PATH
6583 do
6584   IFS=$as_save_IFS
6585   test -z "$as_dir" && as_dir=.
6586     for ac_exec_ext in '' $ac_executable_extensions; do
6587   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6588     ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
6589     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6590     break 2
6591   fi
6592 done
6593   done
6594 IFS=$as_save_IFS
6595 
6596   ;;
6597 esac
6598 fi
6599 CUT=$ac_cv_path_CUT
6600 if test -n "$CUT"; then
6601   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
6602 $as_echo "$CUT" >&6; }
6603 else
6604   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6605 $as_echo "no" >&6; }
6606 fi
6607 
6608 
6609   test -n "$CUT" && break
6610 done
6611 
6612   else
6613     # The variable is set, but is it from the command line or the environment?
6614 
6615     # Try to remove the string !CUT! from our list.
6616     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CUT!/}
6617     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6618       # If it failed, the variable was not from the command line. Ignore it,
6619       # but warn the user (except for BASH, which is always set by the calling BASH).
6620       if test "xCUT" != xBASH; then
6621         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CUT from the environment. Use command line variables instead." >&5
6622 $as_echo "$as_me: WARNING: Ignoring value of CUT from the environment. Use command line variables instead." >&2;}
6623       fi
6624       # Try to locate tool using the code snippet
6625       for ac_prog in cut
6626 do
6627   # Extract the first word of "$ac_prog", so it can be a program name with args.
6628 set dummy $ac_prog; ac_word=$2
6629 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6630 $as_echo_n "checking for $ac_word... " >&6; }
6631 if ${ac_cv_path_CUT+:} false; then :
6632   $as_echo_n "(cached) " >&6
6633 else
6634   case $CUT in
6635   [\\/]* | ?:[\\/]*)
6636   ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
6637   ;;
6638   *)
6639   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6640 for as_dir in $PATH
6641 do
6642   IFS=$as_save_IFS
6643   test -z "$as_dir" && as_dir=.
6644     for ac_exec_ext in '' $ac_executable_extensions; do
6645   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6646     ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
6647     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6648     break 2
6649   fi
6650 done
6651   done
6652 IFS=$as_save_IFS
6653 
6654   ;;
6655 esac
6656 fi
6657 CUT=$ac_cv_path_CUT
6658 if test -n "$CUT"; then
6659   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
6660 $as_echo "$CUT" >&6; }
6661 else
6662   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6663 $as_echo "no" >&6; }
6664 fi
6665 
6666 
6667   test -n "$CUT" && break
6668 done
6669 
6670     else
6671       # If it succeeded, then it was overridden by the user. We will use it
6672       # for the tool.
6673 
6674       # First remove it from the list of overridden variables, so we can test
6675       # for unknown variables in the end.
6676       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6677 
6678       # Check if we try to supply an empty value
6679       if test "x$CUT" = x; then
6680         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CUT= (no value)" >&5
6681 $as_echo "$as_me: Setting user supplied tool CUT= (no value)" >&6;}
6682         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CUT" >&5
6683 $as_echo_n "checking for CUT... " >&6; }
6684         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
6685 $as_echo "disabled" >&6; }
6686       else
6687         # Check if the provided tool contains a complete path.
6688         tool_specified="$CUT"
6689         tool_basename="${tool_specified##*/}"
6690         if test "x$tool_basename" = "x$tool_specified"; then
6691           # A command without a complete path is provided, search $PATH.
6692           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CUT=$tool_basename" >&5
6693 $as_echo "$as_me: Will search for user supplied tool CUT=$tool_basename" >&6;}
6694           # Extract the first word of "$tool_basename", so it can be a program name with args.
6695 set dummy $tool_basename; ac_word=$2
6696 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6697 $as_echo_n "checking for $ac_word... " >&6; }
6698 if ${ac_cv_path_CUT+:} false; then :
6699   $as_echo_n "(cached) " >&6
6700 else
6701   case $CUT in
6702   [\\/]* | ?:[\\/]*)
6703   ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
6704   ;;
6705   *)
6706   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6707 for as_dir in $PATH
6708 do
6709   IFS=$as_save_IFS
6710   test -z "$as_dir" && as_dir=.
6711     for ac_exec_ext in '' $ac_executable_extensions; do
6712   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6713     ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
6714     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6715     break 2
6716   fi
6717 done
6718   done
6719 IFS=$as_save_IFS
6720 
6721   ;;
6722 esac
6723 fi
6724 CUT=$ac_cv_path_CUT
6725 if test -n "$CUT"; then
6726   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
6727 $as_echo "$CUT" >&6; }
6728 else
6729   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6730 $as_echo "no" >&6; }
6731 fi
6732 
6733 
6734           if test "x$CUT" = x; then
6735             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6736           fi
6737         else
6738           # Otherwise we believe it is a complete path. Use it as it is.
6739           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CUT=$tool_specified" >&5
6740 $as_echo "$as_me: Will use user supplied tool CUT=$tool_specified" >&6;}
6741           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CUT" >&5
6742 $as_echo_n "checking for CUT... " >&6; }
6743           if test ! -x "$tool_specified"; then
6744             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6745 $as_echo "not found" >&6; }
6746             as_fn_error $? "User supplied tool CUT=$tool_specified does not exist or is not executable" "$LINENO" 5
6747           fi
6748           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6749 $as_echo "$tool_specified" >&6; }
6750         fi
6751       fi
6752     fi
6753 
6754   fi
6755 
6756 
6757 
6758   if test "x$CUT" = x; then
6759     as_fn_error $? "Could not find required tool for CUT" "$LINENO" 5
6760   fi
6761 
6762 
6763 
6764 
6765 
6766   # Publish this variable in the help.
6767 
6768 
6769   if [ -z "${DATE+x}" ]; then
6770     # The variable is not set by user, try to locate tool using the code snippet
6771     for ac_prog in date
6772 do
6773   # Extract the first word of "$ac_prog", so it can be a program name with args.
6774 set dummy $ac_prog; ac_word=$2
6775 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6776 $as_echo_n "checking for $ac_word... " >&6; }
6777 if ${ac_cv_path_DATE+:} false; then :
6778   $as_echo_n "(cached) " >&6
6779 else
6780   case $DATE in
6781   [\\/]* | ?:[\\/]*)
6782   ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
6783   ;;
6784   *)
6785   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6786 for as_dir in $PATH
6787 do
6788   IFS=$as_save_IFS
6789   test -z "$as_dir" && as_dir=.
6790     for ac_exec_ext in '' $ac_executable_extensions; do
6791   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6792     ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
6793     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6794     break 2
6795   fi
6796 done
6797   done
6798 IFS=$as_save_IFS
6799 
6800   ;;
6801 esac
6802 fi
6803 DATE=$ac_cv_path_DATE
6804 if test -n "$DATE"; then
6805   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
6806 $as_echo "$DATE" >&6; }
6807 else
6808   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6809 $as_echo "no" >&6; }
6810 fi
6811 
6812 
6813   test -n "$DATE" && break
6814 done
6815 
6816   else
6817     # The variable is set, but is it from the command line or the environment?
6818 
6819     # Try to remove the string !DATE! from our list.
6820     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DATE!/}
6821     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6822       # If it failed, the variable was not from the command line. Ignore it,
6823       # but warn the user (except for BASH, which is always set by the calling BASH).
6824       if test "xDATE" != xBASH; then
6825         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DATE from the environment. Use command line variables instead." >&5
6826 $as_echo "$as_me: WARNING: Ignoring value of DATE from the environment. Use command line variables instead." >&2;}
6827       fi
6828       # Try to locate tool using the code snippet
6829       for ac_prog in date
6830 do
6831   # Extract the first word of "$ac_prog", so it can be a program name with args.
6832 set dummy $ac_prog; ac_word=$2
6833 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6834 $as_echo_n "checking for $ac_word... " >&6; }
6835 if ${ac_cv_path_DATE+:} false; then :
6836   $as_echo_n "(cached) " >&6
6837 else
6838   case $DATE in
6839   [\\/]* | ?:[\\/]*)
6840   ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
6841   ;;
6842   *)
6843   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6844 for as_dir in $PATH
6845 do
6846   IFS=$as_save_IFS
6847   test -z "$as_dir" && as_dir=.
6848     for ac_exec_ext in '' $ac_executable_extensions; do
6849   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6850     ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
6851     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6852     break 2
6853   fi
6854 done
6855   done
6856 IFS=$as_save_IFS
6857 
6858   ;;
6859 esac
6860 fi
6861 DATE=$ac_cv_path_DATE
6862 if test -n "$DATE"; then
6863   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
6864 $as_echo "$DATE" >&6; }
6865 else
6866   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6867 $as_echo "no" >&6; }
6868 fi
6869 
6870 
6871   test -n "$DATE" && break
6872 done
6873 
6874     else
6875       # If it succeeded, then it was overridden by the user. We will use it
6876       # for the tool.
6877 
6878       # First remove it from the list of overridden variables, so we can test
6879       # for unknown variables in the end.
6880       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6881 
6882       # Check if we try to supply an empty value
6883       if test "x$DATE" = x; then
6884         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool DATE= (no value)" >&5
6885 $as_echo "$as_me: Setting user supplied tool DATE= (no value)" >&6;}
6886         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DATE" >&5
6887 $as_echo_n "checking for DATE... " >&6; }
6888         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
6889 $as_echo "disabled" >&6; }
6890       else
6891         # Check if the provided tool contains a complete path.
6892         tool_specified="$DATE"
6893         tool_basename="${tool_specified##*/}"
6894         if test "x$tool_basename" = "x$tool_specified"; then
6895           # A command without a complete path is provided, search $PATH.
6896           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DATE=$tool_basename" >&5
6897 $as_echo "$as_me: Will search for user supplied tool DATE=$tool_basename" >&6;}
6898           # Extract the first word of "$tool_basename", so it can be a program name with args.
6899 set dummy $tool_basename; ac_word=$2
6900 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6901 $as_echo_n "checking for $ac_word... " >&6; }
6902 if ${ac_cv_path_DATE+:} false; then :
6903   $as_echo_n "(cached) " >&6
6904 else
6905   case $DATE in
6906   [\\/]* | ?:[\\/]*)
6907   ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
6908   ;;
6909   *)
6910   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6911 for as_dir in $PATH
6912 do
6913   IFS=$as_save_IFS
6914   test -z "$as_dir" && as_dir=.
6915     for ac_exec_ext in '' $ac_executable_extensions; do
6916   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6917     ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
6918     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6919     break 2
6920   fi
6921 done
6922   done
6923 IFS=$as_save_IFS
6924 
6925   ;;
6926 esac
6927 fi
6928 DATE=$ac_cv_path_DATE
6929 if test -n "$DATE"; then
6930   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
6931 $as_echo "$DATE" >&6; }
6932 else
6933   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6934 $as_echo "no" >&6; }
6935 fi
6936 
6937 
6938           if test "x$DATE" = x; then
6939             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6940           fi
6941         else
6942           # Otherwise we believe it is a complete path. Use it as it is.
6943           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DATE=$tool_specified" >&5
6944 $as_echo "$as_me: Will use user supplied tool DATE=$tool_specified" >&6;}
6945           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DATE" >&5
6946 $as_echo_n "checking for DATE... " >&6; }
6947           if test ! -x "$tool_specified"; then
6948             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6949 $as_echo "not found" >&6; }
6950             as_fn_error $? "User supplied tool DATE=$tool_specified does not exist or is not executable" "$LINENO" 5
6951           fi
6952           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6953 $as_echo "$tool_specified" >&6; }
6954         fi
6955       fi
6956     fi
6957 
6958   fi
6959 
6960 
6961 
6962   if test "x$DATE" = x; then
6963     as_fn_error $? "Could not find required tool for DATE" "$LINENO" 5
6964   fi
6965 
6966 
6967 
6968 
6969 
6970   # Publish this variable in the help.
6971 
6972 
6973   if [ -z "${DIFF+x}" ]; then
6974     # The variable is not set by user, try to locate tool using the code snippet
6975     for ac_prog in gdiff diff
6976 do
6977   # Extract the first word of "$ac_prog", so it can be a program name with args.
6978 set dummy $ac_prog; ac_word=$2
6979 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6980 $as_echo_n "checking for $ac_word... " >&6; }
6981 if ${ac_cv_path_DIFF+:} false; then :
6982   $as_echo_n "(cached) " >&6
6983 else
6984   case $DIFF in
6985   [\\/]* | ?:[\\/]*)
6986   ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
6987   ;;
6988   *)
6989   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6990 for as_dir in $PATH
6991 do
6992   IFS=$as_save_IFS
6993   test -z "$as_dir" && as_dir=.
6994     for ac_exec_ext in '' $ac_executable_extensions; do
6995   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6996     ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
6997     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6998     break 2
6999   fi
7000 done
7001   done
7002 IFS=$as_save_IFS
7003 
7004   ;;
7005 esac
7006 fi
7007 DIFF=$ac_cv_path_DIFF
7008 if test -n "$DIFF"; then
7009   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
7010 $as_echo "$DIFF" >&6; }
7011 else
7012   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7013 $as_echo "no" >&6; }
7014 fi
7015 
7016 
7017   test -n "$DIFF" && break
7018 done
7019 
7020   else
7021     # The variable is set, but is it from the command line or the environment?
7022 
7023     # Try to remove the string !DIFF! from our list.
7024     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DIFF!/}
7025     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7026       # If it failed, the variable was not from the command line. Ignore it,
7027       # but warn the user (except for BASH, which is always set by the calling BASH).
7028       if test "xDIFF" != xBASH; then
7029         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DIFF from the environment. Use command line variables instead." >&5
7030 $as_echo "$as_me: WARNING: Ignoring value of DIFF from the environment. Use command line variables instead." >&2;}
7031       fi
7032       # Try to locate tool using the code snippet
7033       for ac_prog in gdiff diff
7034 do
7035   # Extract the first word of "$ac_prog", so it can be a program name with args.
7036 set dummy $ac_prog; ac_word=$2
7037 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7038 $as_echo_n "checking for $ac_word... " >&6; }
7039 if ${ac_cv_path_DIFF+:} false; then :
7040   $as_echo_n "(cached) " >&6
7041 else
7042   case $DIFF in
7043   [\\/]* | ?:[\\/]*)
7044   ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
7045   ;;
7046   *)
7047   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7048 for as_dir in $PATH
7049 do
7050   IFS=$as_save_IFS
7051   test -z "$as_dir" && as_dir=.
7052     for ac_exec_ext in '' $ac_executable_extensions; do
7053   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7054     ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
7055     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7056     break 2
7057   fi
7058 done
7059   done
7060 IFS=$as_save_IFS
7061 
7062   ;;
7063 esac
7064 fi
7065 DIFF=$ac_cv_path_DIFF
7066 if test -n "$DIFF"; then
7067   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
7068 $as_echo "$DIFF" >&6; }
7069 else
7070   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7071 $as_echo "no" >&6; }
7072 fi
7073 
7074 
7075   test -n "$DIFF" && break
7076 done
7077 
7078     else
7079       # If it succeeded, then it was overridden by the user. We will use it
7080       # for the tool.
7081 
7082       # First remove it from the list of overridden variables, so we can test
7083       # for unknown variables in the end.
7084       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7085 
7086       # Check if we try to supply an empty value
7087       if test "x$DIFF" = x; then
7088         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool DIFF= (no value)" >&5
7089 $as_echo "$as_me: Setting user supplied tool DIFF= (no value)" >&6;}
7090         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIFF" >&5
7091 $as_echo_n "checking for DIFF... " >&6; }
7092         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
7093 $as_echo "disabled" >&6; }
7094       else
7095         # Check if the provided tool contains a complete path.
7096         tool_specified="$DIFF"
7097         tool_basename="${tool_specified##*/}"
7098         if test "x$tool_basename" = "x$tool_specified"; then
7099           # A command without a complete path is provided, search $PATH.
7100           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DIFF=$tool_basename" >&5
7101 $as_echo "$as_me: Will search for user supplied tool DIFF=$tool_basename" >&6;}
7102           # Extract the first word of "$tool_basename", so it can be a program name with args.
7103 set dummy $tool_basename; ac_word=$2
7104 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7105 $as_echo_n "checking for $ac_word... " >&6; }
7106 if ${ac_cv_path_DIFF+:} false; then :
7107   $as_echo_n "(cached) " >&6
7108 else
7109   case $DIFF in
7110   [\\/]* | ?:[\\/]*)
7111   ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
7112   ;;
7113   *)
7114   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7115 for as_dir in $PATH
7116 do
7117   IFS=$as_save_IFS
7118   test -z "$as_dir" && as_dir=.
7119     for ac_exec_ext in '' $ac_executable_extensions; do
7120   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7121     ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
7122     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7123     break 2
7124   fi
7125 done
7126   done
7127 IFS=$as_save_IFS
7128 
7129   ;;
7130 esac
7131 fi
7132 DIFF=$ac_cv_path_DIFF
7133 if test -n "$DIFF"; then
7134   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
7135 $as_echo "$DIFF" >&6; }
7136 else
7137   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7138 $as_echo "no" >&6; }
7139 fi
7140 
7141 
7142           if test "x$DIFF" = x; then
7143             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7144           fi
7145         else
7146           # Otherwise we believe it is a complete path. Use it as it is.
7147           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DIFF=$tool_specified" >&5
7148 $as_echo "$as_me: Will use user supplied tool DIFF=$tool_specified" >&6;}
7149           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIFF" >&5
7150 $as_echo_n "checking for DIFF... " >&6; }
7151           if test ! -x "$tool_specified"; then
7152             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7153 $as_echo "not found" >&6; }
7154             as_fn_error $? "User supplied tool DIFF=$tool_specified does not exist or is not executable" "$LINENO" 5
7155           fi
7156           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7157 $as_echo "$tool_specified" >&6; }
7158         fi
7159       fi
7160     fi
7161 
7162   fi
7163 
7164 
7165 
7166   if test "x$DIFF" = x; then
7167     as_fn_error $? "Could not find required tool for DIFF" "$LINENO" 5
7168   fi
7169 
7170 
7171 
7172 
7173 
7174   # Publish this variable in the help.
7175 
7176 
7177   if [ -z "${DIRNAME+x}" ]; then
7178     # The variable is not set by user, try to locate tool using the code snippet
7179     for ac_prog in dirname
7180 do
7181   # Extract the first word of "$ac_prog", so it can be a program name with args.
7182 set dummy $ac_prog; ac_word=$2
7183 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7184 $as_echo_n "checking for $ac_word... " >&6; }
7185 if ${ac_cv_path_DIRNAME+:} false; then :
7186   $as_echo_n "(cached) " >&6
7187 else
7188   case $DIRNAME in
7189   [\\/]* | ?:[\\/]*)
7190   ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
7191   ;;
7192   *)
7193   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7194 for as_dir in $PATH
7195 do
7196   IFS=$as_save_IFS
7197   test -z "$as_dir" && as_dir=.
7198     for ac_exec_ext in '' $ac_executable_extensions; do
7199   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7200     ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
7201     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7202     break 2
7203   fi
7204 done
7205   done
7206 IFS=$as_save_IFS
7207 
7208   ;;
7209 esac
7210 fi
7211 DIRNAME=$ac_cv_path_DIRNAME
7212 if test -n "$DIRNAME"; then
7213   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
7214 $as_echo "$DIRNAME" >&6; }
7215 else
7216   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7217 $as_echo "no" >&6; }
7218 fi
7219 
7220 
7221   test -n "$DIRNAME" && break
7222 done
7223 
7224   else
7225     # The variable is set, but is it from the command line or the environment?
7226 
7227     # Try to remove the string !DIRNAME! from our list.
7228     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DIRNAME!/}
7229     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7230       # If it failed, the variable was not from the command line. Ignore it,
7231       # but warn the user (except for BASH, which is always set by the calling BASH).
7232       if test "xDIRNAME" != xBASH; then
7233         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DIRNAME from the environment. Use command line variables instead." >&5
7234 $as_echo "$as_me: WARNING: Ignoring value of DIRNAME from the environment. Use command line variables instead." >&2;}
7235       fi
7236       # Try to locate tool using the code snippet
7237       for ac_prog in dirname
7238 do
7239   # Extract the first word of "$ac_prog", so it can be a program name with args.
7240 set dummy $ac_prog; ac_word=$2
7241 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7242 $as_echo_n "checking for $ac_word... " >&6; }
7243 if ${ac_cv_path_DIRNAME+:} false; then :
7244   $as_echo_n "(cached) " >&6
7245 else
7246   case $DIRNAME in
7247   [\\/]* | ?:[\\/]*)
7248   ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
7249   ;;
7250   *)
7251   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7252 for as_dir in $PATH
7253 do
7254   IFS=$as_save_IFS
7255   test -z "$as_dir" && as_dir=.
7256     for ac_exec_ext in '' $ac_executable_extensions; do
7257   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7258     ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
7259     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7260     break 2
7261   fi
7262 done
7263   done
7264 IFS=$as_save_IFS
7265 
7266   ;;
7267 esac
7268 fi
7269 DIRNAME=$ac_cv_path_DIRNAME
7270 if test -n "$DIRNAME"; then
7271   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
7272 $as_echo "$DIRNAME" >&6; }
7273 else
7274   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7275 $as_echo "no" >&6; }
7276 fi
7277 
7278 
7279   test -n "$DIRNAME" && break
7280 done
7281 
7282     else
7283       # If it succeeded, then it was overridden by the user. We will use it
7284       # for the tool.
7285 
7286       # First remove it from the list of overridden variables, so we can test
7287       # for unknown variables in the end.
7288       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7289 
7290       # Check if we try to supply an empty value
7291       if test "x$DIRNAME" = x; then
7292         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool DIRNAME= (no value)" >&5
7293 $as_echo "$as_me: Setting user supplied tool DIRNAME= (no value)" >&6;}
7294         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIRNAME" >&5
7295 $as_echo_n "checking for DIRNAME... " >&6; }
7296         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
7297 $as_echo "disabled" >&6; }
7298       else
7299         # Check if the provided tool contains a complete path.
7300         tool_specified="$DIRNAME"
7301         tool_basename="${tool_specified##*/}"
7302         if test "x$tool_basename" = "x$tool_specified"; then
7303           # A command without a complete path is provided, search $PATH.
7304           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DIRNAME=$tool_basename" >&5
7305 $as_echo "$as_me: Will search for user supplied tool DIRNAME=$tool_basename" >&6;}
7306           # Extract the first word of "$tool_basename", so it can be a program name with args.
7307 set dummy $tool_basename; ac_word=$2
7308 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7309 $as_echo_n "checking for $ac_word... " >&6; }
7310 if ${ac_cv_path_DIRNAME+:} false; then :
7311   $as_echo_n "(cached) " >&6
7312 else
7313   case $DIRNAME in
7314   [\\/]* | ?:[\\/]*)
7315   ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
7316   ;;
7317   *)
7318   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7319 for as_dir in $PATH
7320 do
7321   IFS=$as_save_IFS
7322   test -z "$as_dir" && as_dir=.
7323     for ac_exec_ext in '' $ac_executable_extensions; do
7324   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7325     ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
7326     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7327     break 2
7328   fi
7329 done
7330   done
7331 IFS=$as_save_IFS
7332 
7333   ;;
7334 esac
7335 fi
7336 DIRNAME=$ac_cv_path_DIRNAME
7337 if test -n "$DIRNAME"; then
7338   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
7339 $as_echo "$DIRNAME" >&6; }
7340 else
7341   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7342 $as_echo "no" >&6; }
7343 fi
7344 
7345 
7346           if test "x$DIRNAME" = x; then
7347             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7348           fi
7349         else
7350           # Otherwise we believe it is a complete path. Use it as it is.
7351           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DIRNAME=$tool_specified" >&5
7352 $as_echo "$as_me: Will use user supplied tool DIRNAME=$tool_specified" >&6;}
7353           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIRNAME" >&5
7354 $as_echo_n "checking for DIRNAME... " >&6; }
7355           if test ! -x "$tool_specified"; then
7356             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7357 $as_echo "not found" >&6; }
7358             as_fn_error $? "User supplied tool DIRNAME=$tool_specified does not exist or is not executable" "$LINENO" 5
7359           fi
7360           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7361 $as_echo "$tool_specified" >&6; }
7362         fi
7363       fi
7364     fi
7365 
7366   fi
7367 
7368 
7369 
7370   if test "x$DIRNAME" = x; then
7371     as_fn_error $? "Could not find required tool for DIRNAME" "$LINENO" 5
7372   fi
7373 
7374 
7375 
7376 
7377 
7378   # Publish this variable in the help.
7379 
7380 
7381   if [ -z "${ECHO+x}" ]; then
7382     # The variable is not set by user, try to locate tool using the code snippet
7383     for ac_prog in echo
7384 do
7385   # Extract the first word of "$ac_prog", so it can be a program name with args.
7386 set dummy $ac_prog; ac_word=$2
7387 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7388 $as_echo_n "checking for $ac_word... " >&6; }
7389 if ${ac_cv_path_ECHO+:} false; then :
7390   $as_echo_n "(cached) " >&6
7391 else
7392   case $ECHO in
7393   [\\/]* | ?:[\\/]*)
7394   ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
7395   ;;
7396   *)
7397   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7398 for as_dir in $PATH
7399 do
7400   IFS=$as_save_IFS
7401   test -z "$as_dir" && as_dir=.
7402     for ac_exec_ext in '' $ac_executable_extensions; do
7403   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7404     ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
7405     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7406     break 2
7407   fi
7408 done
7409   done
7410 IFS=$as_save_IFS
7411 
7412   ;;
7413 esac
7414 fi
7415 ECHO=$ac_cv_path_ECHO
7416 if test -n "$ECHO"; then
7417   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
7418 $as_echo "$ECHO" >&6; }
7419 else
7420   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7421 $as_echo "no" >&6; }
7422 fi
7423 
7424 
7425   test -n "$ECHO" && break
7426 done
7427 
7428   else
7429     # The variable is set, but is it from the command line or the environment?
7430 
7431     # Try to remove the string !ECHO! from our list.
7432     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!ECHO!/}
7433     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7434       # If it failed, the variable was not from the command line. Ignore it,
7435       # but warn the user (except for BASH, which is always set by the calling BASH).
7436       if test "xECHO" != xBASH; then
7437         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ECHO from the environment. Use command line variables instead." >&5
7438 $as_echo "$as_me: WARNING: Ignoring value of ECHO from the environment. Use command line variables instead." >&2;}
7439       fi
7440       # Try to locate tool using the code snippet
7441       for ac_prog in echo
7442 do
7443   # Extract the first word of "$ac_prog", so it can be a program name with args.
7444 set dummy $ac_prog; ac_word=$2
7445 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7446 $as_echo_n "checking for $ac_word... " >&6; }
7447 if ${ac_cv_path_ECHO+:} false; then :
7448   $as_echo_n "(cached) " >&6
7449 else
7450   case $ECHO in
7451   [\\/]* | ?:[\\/]*)
7452   ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
7453   ;;
7454   *)
7455   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7456 for as_dir in $PATH
7457 do
7458   IFS=$as_save_IFS
7459   test -z "$as_dir" && as_dir=.
7460     for ac_exec_ext in '' $ac_executable_extensions; do
7461   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7462     ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
7463     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7464     break 2
7465   fi
7466 done
7467   done
7468 IFS=$as_save_IFS
7469 
7470   ;;
7471 esac
7472 fi
7473 ECHO=$ac_cv_path_ECHO
7474 if test -n "$ECHO"; then
7475   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
7476 $as_echo "$ECHO" >&6; }
7477 else
7478   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7479 $as_echo "no" >&6; }
7480 fi
7481 
7482 
7483   test -n "$ECHO" && break
7484 done
7485 
7486     else
7487       # If it succeeded, then it was overridden by the user. We will use it
7488       # for the tool.
7489 
7490       # First remove it from the list of overridden variables, so we can test
7491       # for unknown variables in the end.
7492       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7493 
7494       # Check if we try to supply an empty value
7495       if test "x$ECHO" = x; then
7496         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool ECHO= (no value)" >&5
7497 $as_echo "$as_me: Setting user supplied tool ECHO= (no value)" >&6;}
7498         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ECHO" >&5
7499 $as_echo_n "checking for ECHO... " >&6; }
7500         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
7501 $as_echo "disabled" >&6; }
7502       else
7503         # Check if the provided tool contains a complete path.
7504         tool_specified="$ECHO"
7505         tool_basename="${tool_specified##*/}"
7506         if test "x$tool_basename" = "x$tool_specified"; then
7507           # A command without a complete path is provided, search $PATH.
7508           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ECHO=$tool_basename" >&5
7509 $as_echo "$as_me: Will search for user supplied tool ECHO=$tool_basename" >&6;}
7510           # Extract the first word of "$tool_basename", so it can be a program name with args.
7511 set dummy $tool_basename; ac_word=$2
7512 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7513 $as_echo_n "checking for $ac_word... " >&6; }
7514 if ${ac_cv_path_ECHO+:} false; then :
7515   $as_echo_n "(cached) " >&6
7516 else
7517   case $ECHO in
7518   [\\/]* | ?:[\\/]*)
7519   ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
7520   ;;
7521   *)
7522   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7523 for as_dir in $PATH
7524 do
7525   IFS=$as_save_IFS
7526   test -z "$as_dir" && as_dir=.
7527     for ac_exec_ext in '' $ac_executable_extensions; do
7528   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7529     ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
7530     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7531     break 2
7532   fi
7533 done
7534   done
7535 IFS=$as_save_IFS
7536 
7537   ;;
7538 esac
7539 fi
7540 ECHO=$ac_cv_path_ECHO
7541 if test -n "$ECHO"; then
7542   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
7543 $as_echo "$ECHO" >&6; }
7544 else
7545   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7546 $as_echo "no" >&6; }
7547 fi
7548 
7549 
7550           if test "x$ECHO" = x; then
7551             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7552           fi
7553         else
7554           # Otherwise we believe it is a complete path. Use it as it is.
7555           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ECHO=$tool_specified" >&5
7556 $as_echo "$as_me: Will use user supplied tool ECHO=$tool_specified" >&6;}
7557           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ECHO" >&5
7558 $as_echo_n "checking for ECHO... " >&6; }
7559           if test ! -x "$tool_specified"; then
7560             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7561 $as_echo "not found" >&6; }
7562             as_fn_error $? "User supplied tool ECHO=$tool_specified does not exist or is not executable" "$LINENO" 5
7563           fi
7564           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7565 $as_echo "$tool_specified" >&6; }
7566         fi
7567       fi
7568     fi
7569 
7570   fi
7571 
7572 
7573 
7574   if test "x$ECHO" = x; then
7575     as_fn_error $? "Could not find required tool for ECHO" "$LINENO" 5
7576   fi
7577 
7578 
7579 
7580 
7581 
7582   # Publish this variable in the help.
7583 
7584 
7585   if [ -z "${EXPR+x}" ]; then
7586     # The variable is not set by user, try to locate tool using the code snippet
7587     for ac_prog in expr
7588 do
7589   # Extract the first word of "$ac_prog", so it can be a program name with args.
7590 set dummy $ac_prog; ac_word=$2
7591 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7592 $as_echo_n "checking for $ac_word... " >&6; }
7593 if ${ac_cv_path_EXPR+:} false; then :
7594   $as_echo_n "(cached) " >&6
7595 else
7596   case $EXPR in
7597   [\\/]* | ?:[\\/]*)
7598   ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
7599   ;;
7600   *)
7601   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7602 for as_dir in $PATH
7603 do
7604   IFS=$as_save_IFS
7605   test -z "$as_dir" && as_dir=.
7606     for ac_exec_ext in '' $ac_executable_extensions; do
7607   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7608     ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
7609     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7610     break 2
7611   fi
7612 done
7613   done
7614 IFS=$as_save_IFS
7615 
7616   ;;
7617 esac
7618 fi
7619 EXPR=$ac_cv_path_EXPR
7620 if test -n "$EXPR"; then
7621   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
7622 $as_echo "$EXPR" >&6; }
7623 else
7624   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7625 $as_echo "no" >&6; }
7626 fi
7627 
7628 
7629   test -n "$EXPR" && break
7630 done
7631 
7632   else
7633     # The variable is set, but is it from the command line or the environment?
7634 
7635     # Try to remove the string !EXPR! from our list.
7636     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!EXPR!/}
7637     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7638       # If it failed, the variable was not from the command line. Ignore it,
7639       # but warn the user (except for BASH, which is always set by the calling BASH).
7640       if test "xEXPR" != xBASH; then
7641         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of EXPR from the environment. Use command line variables instead." >&5
7642 $as_echo "$as_me: WARNING: Ignoring value of EXPR from the environment. Use command line variables instead." >&2;}
7643       fi
7644       # Try to locate tool using the code snippet
7645       for ac_prog in expr
7646 do
7647   # Extract the first word of "$ac_prog", so it can be a program name with args.
7648 set dummy $ac_prog; ac_word=$2
7649 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7650 $as_echo_n "checking for $ac_word... " >&6; }
7651 if ${ac_cv_path_EXPR+:} false; then :
7652   $as_echo_n "(cached) " >&6
7653 else
7654   case $EXPR in
7655   [\\/]* | ?:[\\/]*)
7656   ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
7657   ;;
7658   *)
7659   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7660 for as_dir in $PATH
7661 do
7662   IFS=$as_save_IFS
7663   test -z "$as_dir" && as_dir=.
7664     for ac_exec_ext in '' $ac_executable_extensions; do
7665   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7666     ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
7667     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7668     break 2
7669   fi
7670 done
7671   done
7672 IFS=$as_save_IFS
7673 
7674   ;;
7675 esac
7676 fi
7677 EXPR=$ac_cv_path_EXPR
7678 if test -n "$EXPR"; then
7679   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
7680 $as_echo "$EXPR" >&6; }
7681 else
7682   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7683 $as_echo "no" >&6; }
7684 fi
7685 
7686 
7687   test -n "$EXPR" && break
7688 done
7689 
7690     else
7691       # If it succeeded, then it was overridden by the user. We will use it
7692       # for the tool.
7693 
7694       # First remove it from the list of overridden variables, so we can test
7695       # for unknown variables in the end.
7696       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7697 
7698       # Check if we try to supply an empty value
7699       if test "x$EXPR" = x; then
7700         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool EXPR= (no value)" >&5
7701 $as_echo "$as_me: Setting user supplied tool EXPR= (no value)" >&6;}
7702         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EXPR" >&5
7703 $as_echo_n "checking for EXPR... " >&6; }
7704         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
7705 $as_echo "disabled" >&6; }
7706       else
7707         # Check if the provided tool contains a complete path.
7708         tool_specified="$EXPR"
7709         tool_basename="${tool_specified##*/}"
7710         if test "x$tool_basename" = "x$tool_specified"; then
7711           # A command without a complete path is provided, search $PATH.
7712           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool EXPR=$tool_basename" >&5
7713 $as_echo "$as_me: Will search for user supplied tool EXPR=$tool_basename" >&6;}
7714           # Extract the first word of "$tool_basename", so it can be a program name with args.
7715 set dummy $tool_basename; ac_word=$2
7716 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7717 $as_echo_n "checking for $ac_word... " >&6; }
7718 if ${ac_cv_path_EXPR+:} false; then :
7719   $as_echo_n "(cached) " >&6
7720 else
7721   case $EXPR in
7722   [\\/]* | ?:[\\/]*)
7723   ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
7724   ;;
7725   *)
7726   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7727 for as_dir in $PATH
7728 do
7729   IFS=$as_save_IFS
7730   test -z "$as_dir" && as_dir=.
7731     for ac_exec_ext in '' $ac_executable_extensions; do
7732   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7733     ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
7734     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7735     break 2
7736   fi
7737 done
7738   done
7739 IFS=$as_save_IFS
7740 
7741   ;;
7742 esac
7743 fi
7744 EXPR=$ac_cv_path_EXPR
7745 if test -n "$EXPR"; then
7746   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
7747 $as_echo "$EXPR" >&6; }
7748 else
7749   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7750 $as_echo "no" >&6; }
7751 fi
7752 
7753 
7754           if test "x$EXPR" = x; then
7755             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7756           fi
7757         else
7758           # Otherwise we believe it is a complete path. Use it as it is.
7759           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool EXPR=$tool_specified" >&5
7760 $as_echo "$as_me: Will use user supplied tool EXPR=$tool_specified" >&6;}
7761           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EXPR" >&5
7762 $as_echo_n "checking for EXPR... " >&6; }
7763           if test ! -x "$tool_specified"; then
7764             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7765 $as_echo "not found" >&6; }
7766             as_fn_error $? "User supplied tool EXPR=$tool_specified does not exist or is not executable" "$LINENO" 5
7767           fi
7768           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7769 $as_echo "$tool_specified" >&6; }
7770         fi
7771       fi
7772     fi
7773 
7774   fi
7775 
7776 
7777 
7778   if test "x$EXPR" = x; then
7779     as_fn_error $? "Could not find required tool for EXPR" "$LINENO" 5
7780   fi
7781 
7782 
7783 
7784 
7785 
7786   # Publish this variable in the help.
7787 
7788 
7789   if [ -z "${FILE+x}" ]; then
7790     # The variable is not set by user, try to locate tool using the code snippet
7791     for ac_prog in file
7792 do
7793   # Extract the first word of "$ac_prog", so it can be a program name with args.
7794 set dummy $ac_prog; ac_word=$2
7795 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7796 $as_echo_n "checking for $ac_word... " >&6; }
7797 if ${ac_cv_path_FILE+:} false; then :
7798   $as_echo_n "(cached) " >&6
7799 else
7800   case $FILE in
7801   [\\/]* | ?:[\\/]*)
7802   ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
7803   ;;
7804   *)
7805   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7806 for as_dir in $PATH
7807 do
7808   IFS=$as_save_IFS
7809   test -z "$as_dir" && as_dir=.
7810     for ac_exec_ext in '' $ac_executable_extensions; do
7811   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7812     ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
7813     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7814     break 2
7815   fi
7816 done
7817   done
7818 IFS=$as_save_IFS
7819 
7820   ;;
7821 esac
7822 fi
7823 FILE=$ac_cv_path_FILE
7824 if test -n "$FILE"; then
7825   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
7826 $as_echo "$FILE" >&6; }
7827 else
7828   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7829 $as_echo "no" >&6; }
7830 fi
7831 
7832 
7833   test -n "$FILE" && break
7834 done
7835 
7836   else
7837     # The variable is set, but is it from the command line or the environment?
7838 
7839     # Try to remove the string !FILE! from our list.
7840     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FILE!/}
7841     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7842       # If it failed, the variable was not from the command line. Ignore it,
7843       # but warn the user (except for BASH, which is always set by the calling BASH).
7844       if test "xFILE" != xBASH; then
7845         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FILE from the environment. Use command line variables instead." >&5
7846 $as_echo "$as_me: WARNING: Ignoring value of FILE from the environment. Use command line variables instead." >&2;}
7847       fi
7848       # Try to locate tool using the code snippet
7849       for ac_prog in file
7850 do
7851   # Extract the first word of "$ac_prog", so it can be a program name with args.
7852 set dummy $ac_prog; ac_word=$2
7853 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7854 $as_echo_n "checking for $ac_word... " >&6; }
7855 if ${ac_cv_path_FILE+:} false; then :
7856   $as_echo_n "(cached) " >&6
7857 else
7858   case $FILE in
7859   [\\/]* | ?:[\\/]*)
7860   ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
7861   ;;
7862   *)
7863   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7864 for as_dir in $PATH
7865 do
7866   IFS=$as_save_IFS
7867   test -z "$as_dir" && as_dir=.
7868     for ac_exec_ext in '' $ac_executable_extensions; do
7869   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7870     ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
7871     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7872     break 2
7873   fi
7874 done
7875   done
7876 IFS=$as_save_IFS
7877 
7878   ;;
7879 esac
7880 fi
7881 FILE=$ac_cv_path_FILE
7882 if test -n "$FILE"; then
7883   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
7884 $as_echo "$FILE" >&6; }
7885 else
7886   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7887 $as_echo "no" >&6; }
7888 fi
7889 
7890 
7891   test -n "$FILE" && break
7892 done
7893 
7894     else
7895       # If it succeeded, then it was overridden by the user. We will use it
7896       # for the tool.
7897 
7898       # First remove it from the list of overridden variables, so we can test
7899       # for unknown variables in the end.
7900       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7901 
7902       # Check if we try to supply an empty value
7903       if test "x$FILE" = x; then
7904         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool FILE= (no value)" >&5
7905 $as_echo "$as_me: Setting user supplied tool FILE= (no value)" >&6;}
7906         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FILE" >&5
7907 $as_echo_n "checking for FILE... " >&6; }
7908         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
7909 $as_echo "disabled" >&6; }
7910       else
7911         # Check if the provided tool contains a complete path.
7912         tool_specified="$FILE"
7913         tool_basename="${tool_specified##*/}"
7914         if test "x$tool_basename" = "x$tool_specified"; then
7915           # A command without a complete path is provided, search $PATH.
7916           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FILE=$tool_basename" >&5
7917 $as_echo "$as_me: Will search for user supplied tool FILE=$tool_basename" >&6;}
7918           # Extract the first word of "$tool_basename", so it can be a program name with args.
7919 set dummy $tool_basename; ac_word=$2
7920 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7921 $as_echo_n "checking for $ac_word... " >&6; }
7922 if ${ac_cv_path_FILE+:} false; then :
7923   $as_echo_n "(cached) " >&6
7924 else
7925   case $FILE in
7926   [\\/]* | ?:[\\/]*)
7927   ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
7928   ;;
7929   *)
7930   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7931 for as_dir in $PATH
7932 do
7933   IFS=$as_save_IFS
7934   test -z "$as_dir" && as_dir=.
7935     for ac_exec_ext in '' $ac_executable_extensions; do
7936   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7937     ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
7938     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7939     break 2
7940   fi
7941 done
7942   done
7943 IFS=$as_save_IFS
7944 
7945   ;;
7946 esac
7947 fi
7948 FILE=$ac_cv_path_FILE
7949 if test -n "$FILE"; then
7950   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
7951 $as_echo "$FILE" >&6; }
7952 else
7953   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7954 $as_echo "no" >&6; }
7955 fi
7956 
7957 
7958           if test "x$FILE" = x; then
7959             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7960           fi
7961         else
7962           # Otherwise we believe it is a complete path. Use it as it is.
7963           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FILE=$tool_specified" >&5
7964 $as_echo "$as_me: Will use user supplied tool FILE=$tool_specified" >&6;}
7965           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FILE" >&5
7966 $as_echo_n "checking for FILE... " >&6; }
7967           if test ! -x "$tool_specified"; then
7968             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7969 $as_echo "not found" >&6; }
7970             as_fn_error $? "User supplied tool FILE=$tool_specified does not exist or is not executable" "$LINENO" 5
7971           fi
7972           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7973 $as_echo "$tool_specified" >&6; }
7974         fi
7975       fi
7976     fi
7977 
7978   fi
7979 
7980 
7981 
7982   if test "x$FILE" = x; then
7983     as_fn_error $? "Could not find required tool for FILE" "$LINENO" 5
7984   fi
7985 
7986 
7987 
7988 
7989 
7990   # Publish this variable in the help.
7991 
7992 
7993   if [ -z "${FIND+x}" ]; then
7994     # The variable is not set by user, try to locate tool using the code snippet
7995     for ac_prog in find
7996 do
7997   # Extract the first word of "$ac_prog", so it can be a program name with args.
7998 set dummy $ac_prog; ac_word=$2
7999 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8000 $as_echo_n "checking for $ac_word... " >&6; }
8001 if ${ac_cv_path_FIND+:} false; then :
8002   $as_echo_n "(cached) " >&6
8003 else
8004   case $FIND in
8005   [\\/]* | ?:[\\/]*)
8006   ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
8007   ;;
8008   *)
8009   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8010 for as_dir in $PATH
8011 do
8012   IFS=$as_save_IFS
8013   test -z "$as_dir" && as_dir=.
8014     for ac_exec_ext in '' $ac_executable_extensions; do
8015   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8016     ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
8017     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8018     break 2
8019   fi
8020 done
8021   done
8022 IFS=$as_save_IFS
8023 
8024   ;;
8025 esac
8026 fi
8027 FIND=$ac_cv_path_FIND
8028 if test -n "$FIND"; then
8029   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
8030 $as_echo "$FIND" >&6; }
8031 else
8032   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8033 $as_echo "no" >&6; }
8034 fi
8035 
8036 
8037   test -n "$FIND" && break
8038 done
8039 
8040   else
8041     # The variable is set, but is it from the command line or the environment?
8042 
8043     # Try to remove the string !FIND! from our list.
8044     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FIND!/}
8045     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8046       # If it failed, the variable was not from the command line. Ignore it,
8047       # but warn the user (except for BASH, which is always set by the calling BASH).
8048       if test "xFIND" != xBASH; then
8049         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FIND from the environment. Use command line variables instead." >&5
8050 $as_echo "$as_me: WARNING: Ignoring value of FIND from the environment. Use command line variables instead." >&2;}
8051       fi
8052       # Try to locate tool using the code snippet
8053       for ac_prog in find
8054 do
8055   # Extract the first word of "$ac_prog", so it can be a program name with args.
8056 set dummy $ac_prog; ac_word=$2
8057 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8058 $as_echo_n "checking for $ac_word... " >&6; }
8059 if ${ac_cv_path_FIND+:} false; then :
8060   $as_echo_n "(cached) " >&6
8061 else
8062   case $FIND in
8063   [\\/]* | ?:[\\/]*)
8064   ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
8065   ;;
8066   *)
8067   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8068 for as_dir in $PATH
8069 do
8070   IFS=$as_save_IFS
8071   test -z "$as_dir" && as_dir=.
8072     for ac_exec_ext in '' $ac_executable_extensions; do
8073   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8074     ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
8075     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8076     break 2
8077   fi
8078 done
8079   done
8080 IFS=$as_save_IFS
8081 
8082   ;;
8083 esac
8084 fi
8085 FIND=$ac_cv_path_FIND
8086 if test -n "$FIND"; then
8087   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
8088 $as_echo "$FIND" >&6; }
8089 else
8090   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8091 $as_echo "no" >&6; }
8092 fi
8093 
8094 
8095   test -n "$FIND" && break
8096 done
8097 
8098     else
8099       # If it succeeded, then it was overridden by the user. We will use it
8100       # for the tool.
8101 
8102       # First remove it from the list of overridden variables, so we can test
8103       # for unknown variables in the end.
8104       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8105 
8106       # Check if we try to supply an empty value
8107       if test "x$FIND" = x; then
8108         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool FIND= (no value)" >&5
8109 $as_echo "$as_me: Setting user supplied tool FIND= (no value)" >&6;}
8110         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FIND" >&5
8111 $as_echo_n "checking for FIND... " >&6; }
8112         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
8113 $as_echo "disabled" >&6; }
8114       else
8115         # Check if the provided tool contains a complete path.
8116         tool_specified="$FIND"
8117         tool_basename="${tool_specified##*/}"
8118         if test "x$tool_basename" = "x$tool_specified"; then
8119           # A command without a complete path is provided, search $PATH.
8120           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FIND=$tool_basename" >&5
8121 $as_echo "$as_me: Will search for user supplied tool FIND=$tool_basename" >&6;}
8122           # Extract the first word of "$tool_basename", so it can be a program name with args.
8123 set dummy $tool_basename; ac_word=$2
8124 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8125 $as_echo_n "checking for $ac_word... " >&6; }
8126 if ${ac_cv_path_FIND+:} false; then :
8127   $as_echo_n "(cached) " >&6
8128 else
8129   case $FIND in
8130   [\\/]* | ?:[\\/]*)
8131   ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
8132   ;;
8133   *)
8134   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8135 for as_dir in $PATH
8136 do
8137   IFS=$as_save_IFS
8138   test -z "$as_dir" && as_dir=.
8139     for ac_exec_ext in '' $ac_executable_extensions; do
8140   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8141     ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
8142     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8143     break 2
8144   fi
8145 done
8146   done
8147 IFS=$as_save_IFS
8148 
8149   ;;
8150 esac
8151 fi
8152 FIND=$ac_cv_path_FIND
8153 if test -n "$FIND"; then
8154   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
8155 $as_echo "$FIND" >&6; }
8156 else
8157   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8158 $as_echo "no" >&6; }
8159 fi
8160 
8161 
8162           if test "x$FIND" = x; then
8163             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8164           fi
8165         else
8166           # Otherwise we believe it is a complete path. Use it as it is.
8167           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FIND=$tool_specified" >&5
8168 $as_echo "$as_me: Will use user supplied tool FIND=$tool_specified" >&6;}
8169           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FIND" >&5
8170 $as_echo_n "checking for FIND... " >&6; }
8171           if test ! -x "$tool_specified"; then
8172             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8173 $as_echo "not found" >&6; }
8174             as_fn_error $? "User supplied tool FIND=$tool_specified does not exist or is not executable" "$LINENO" 5
8175           fi
8176           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8177 $as_echo "$tool_specified" >&6; }
8178         fi
8179       fi
8180     fi
8181 
8182   fi
8183 
8184 
8185 
8186   if test "x$FIND" = x; then
8187     as_fn_error $? "Could not find required tool for FIND" "$LINENO" 5
8188   fi
8189 
8190 
8191 
8192 
8193 
8194   # Publish this variable in the help.
8195 
8196 
8197   if [ -z "${HEAD+x}" ]; then
8198     # The variable is not set by user, try to locate tool using the code snippet
8199     for ac_prog in head
8200 do
8201   # Extract the first word of "$ac_prog", so it can be a program name with args.
8202 set dummy $ac_prog; ac_word=$2
8203 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8204 $as_echo_n "checking for $ac_word... " >&6; }
8205 if ${ac_cv_path_HEAD+:} false; then :
8206   $as_echo_n "(cached) " >&6
8207 else
8208   case $HEAD in
8209   [\\/]* | ?:[\\/]*)
8210   ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
8211   ;;
8212   *)
8213   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8214 for as_dir in $PATH
8215 do
8216   IFS=$as_save_IFS
8217   test -z "$as_dir" && as_dir=.
8218     for ac_exec_ext in '' $ac_executable_extensions; do
8219   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8220     ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
8221     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8222     break 2
8223   fi
8224 done
8225   done
8226 IFS=$as_save_IFS
8227 
8228   ;;
8229 esac
8230 fi
8231 HEAD=$ac_cv_path_HEAD
8232 if test -n "$HEAD"; then
8233   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
8234 $as_echo "$HEAD" >&6; }
8235 else
8236   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8237 $as_echo "no" >&6; }
8238 fi
8239 
8240 
8241   test -n "$HEAD" && break
8242 done
8243 
8244   else
8245     # The variable is set, but is it from the command line or the environment?
8246 
8247     # Try to remove the string !HEAD! from our list.
8248     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!HEAD!/}
8249     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8250       # If it failed, the variable was not from the command line. Ignore it,
8251       # but warn the user (except for BASH, which is always set by the calling BASH).
8252       if test "xHEAD" != xBASH; then
8253         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of HEAD from the environment. Use command line variables instead." >&5
8254 $as_echo "$as_me: WARNING: Ignoring value of HEAD from the environment. Use command line variables instead." >&2;}
8255       fi
8256       # Try to locate tool using the code snippet
8257       for ac_prog in head
8258 do
8259   # Extract the first word of "$ac_prog", so it can be a program name with args.
8260 set dummy $ac_prog; ac_word=$2
8261 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8262 $as_echo_n "checking for $ac_word... " >&6; }
8263 if ${ac_cv_path_HEAD+:} false; then :
8264   $as_echo_n "(cached) " >&6
8265 else
8266   case $HEAD in
8267   [\\/]* | ?:[\\/]*)
8268   ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
8269   ;;
8270   *)
8271   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8272 for as_dir in $PATH
8273 do
8274   IFS=$as_save_IFS
8275   test -z "$as_dir" && as_dir=.
8276     for ac_exec_ext in '' $ac_executable_extensions; do
8277   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8278     ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
8279     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8280     break 2
8281   fi
8282 done
8283   done
8284 IFS=$as_save_IFS
8285 
8286   ;;
8287 esac
8288 fi
8289 HEAD=$ac_cv_path_HEAD
8290 if test -n "$HEAD"; then
8291   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
8292 $as_echo "$HEAD" >&6; }
8293 else
8294   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8295 $as_echo "no" >&6; }
8296 fi
8297 
8298 
8299   test -n "$HEAD" && break
8300 done
8301 
8302     else
8303       # If it succeeded, then it was overridden by the user. We will use it
8304       # for the tool.
8305 
8306       # First remove it from the list of overridden variables, so we can test
8307       # for unknown variables in the end.
8308       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8309 
8310       # Check if we try to supply an empty value
8311       if test "x$HEAD" = x; then
8312         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool HEAD= (no value)" >&5
8313 $as_echo "$as_me: Setting user supplied tool HEAD= (no value)" >&6;}
8314         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HEAD" >&5
8315 $as_echo_n "checking for HEAD... " >&6; }
8316         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
8317 $as_echo "disabled" >&6; }
8318       else
8319         # Check if the provided tool contains a complete path.
8320         tool_specified="$HEAD"
8321         tool_basename="${tool_specified##*/}"
8322         if test "x$tool_basename" = "x$tool_specified"; then
8323           # A command without a complete path is provided, search $PATH.
8324           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool HEAD=$tool_basename" >&5
8325 $as_echo "$as_me: Will search for user supplied tool HEAD=$tool_basename" >&6;}
8326           # Extract the first word of "$tool_basename", so it can be a program name with args.
8327 set dummy $tool_basename; ac_word=$2
8328 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8329 $as_echo_n "checking for $ac_word... " >&6; }
8330 if ${ac_cv_path_HEAD+:} false; then :
8331   $as_echo_n "(cached) " >&6
8332 else
8333   case $HEAD in
8334   [\\/]* | ?:[\\/]*)
8335   ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
8336   ;;
8337   *)
8338   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8339 for as_dir in $PATH
8340 do
8341   IFS=$as_save_IFS
8342   test -z "$as_dir" && as_dir=.
8343     for ac_exec_ext in '' $ac_executable_extensions; do
8344   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8345     ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
8346     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8347     break 2
8348   fi
8349 done
8350   done
8351 IFS=$as_save_IFS
8352 
8353   ;;
8354 esac
8355 fi
8356 HEAD=$ac_cv_path_HEAD
8357 if test -n "$HEAD"; then
8358   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
8359 $as_echo "$HEAD" >&6; }
8360 else
8361   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8362 $as_echo "no" >&6; }
8363 fi
8364 
8365 
8366           if test "x$HEAD" = x; then
8367             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8368           fi
8369         else
8370           # Otherwise we believe it is a complete path. Use it as it is.
8371           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool HEAD=$tool_specified" >&5
8372 $as_echo "$as_me: Will use user supplied tool HEAD=$tool_specified" >&6;}
8373           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HEAD" >&5
8374 $as_echo_n "checking for HEAD... " >&6; }
8375           if test ! -x "$tool_specified"; then
8376             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8377 $as_echo "not found" >&6; }
8378             as_fn_error $? "User supplied tool HEAD=$tool_specified does not exist or is not executable" "$LINENO" 5
8379           fi
8380           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8381 $as_echo "$tool_specified" >&6; }
8382         fi
8383       fi
8384     fi
8385 
8386   fi
8387 
8388 
8389 
8390   if test "x$HEAD" = x; then
8391     as_fn_error $? "Could not find required tool for HEAD" "$LINENO" 5
8392   fi
8393 
8394 
8395 
8396 
8397 
8398   # Publish this variable in the help.
8399 
8400 
8401   if [ -z "${LN+x}" ]; then
8402     # The variable is not set by user, try to locate tool using the code snippet
8403     for ac_prog in ln
8404 do
8405   # Extract the first word of "$ac_prog", so it can be a program name with args.
8406 set dummy $ac_prog; ac_word=$2
8407 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8408 $as_echo_n "checking for $ac_word... " >&6; }
8409 if ${ac_cv_path_LN+:} false; then :
8410   $as_echo_n "(cached) " >&6
8411 else
8412   case $LN in
8413   [\\/]* | ?:[\\/]*)
8414   ac_cv_path_LN="$LN" # Let the user override the test with a path.
8415   ;;
8416   *)
8417   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8418 for as_dir in $PATH
8419 do
8420   IFS=$as_save_IFS
8421   test -z "$as_dir" && as_dir=.
8422     for ac_exec_ext in '' $ac_executable_extensions; do
8423   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8424     ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
8425     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8426     break 2
8427   fi
8428 done
8429   done
8430 IFS=$as_save_IFS
8431 
8432   ;;
8433 esac
8434 fi
8435 LN=$ac_cv_path_LN
8436 if test -n "$LN"; then
8437   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
8438 $as_echo "$LN" >&6; }
8439 else
8440   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8441 $as_echo "no" >&6; }
8442 fi
8443 
8444 
8445   test -n "$LN" && break
8446 done
8447 
8448   else
8449     # The variable is set, but is it from the command line or the environment?
8450 
8451     # Try to remove the string !LN! from our list.
8452     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LN!/}
8453     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8454       # If it failed, the variable was not from the command line. Ignore it,
8455       # but warn the user (except for BASH, which is always set by the calling BASH).
8456       if test "xLN" != xBASH; then
8457         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LN from the environment. Use command line variables instead." >&5
8458 $as_echo "$as_me: WARNING: Ignoring value of LN from the environment. Use command line variables instead." >&2;}
8459       fi
8460       # Try to locate tool using the code snippet
8461       for ac_prog in ln
8462 do
8463   # Extract the first word of "$ac_prog", so it can be a program name with args.
8464 set dummy $ac_prog; ac_word=$2
8465 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8466 $as_echo_n "checking for $ac_word... " >&6; }
8467 if ${ac_cv_path_LN+:} false; then :
8468   $as_echo_n "(cached) " >&6
8469 else
8470   case $LN in
8471   [\\/]* | ?:[\\/]*)
8472   ac_cv_path_LN="$LN" # Let the user override the test with a path.
8473   ;;
8474   *)
8475   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8476 for as_dir in $PATH
8477 do
8478   IFS=$as_save_IFS
8479   test -z "$as_dir" && as_dir=.
8480     for ac_exec_ext in '' $ac_executable_extensions; do
8481   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8482     ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
8483     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8484     break 2
8485   fi
8486 done
8487   done
8488 IFS=$as_save_IFS
8489 
8490   ;;
8491 esac
8492 fi
8493 LN=$ac_cv_path_LN
8494 if test -n "$LN"; then
8495   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
8496 $as_echo "$LN" >&6; }
8497 else
8498   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8499 $as_echo "no" >&6; }
8500 fi
8501 
8502 
8503   test -n "$LN" && break
8504 done
8505 
8506     else
8507       # If it succeeded, then it was overridden by the user. We will use it
8508       # for the tool.
8509 
8510       # First remove it from the list of overridden variables, so we can test
8511       # for unknown variables in the end.
8512       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8513 
8514       # Check if we try to supply an empty value
8515       if test "x$LN" = x; then
8516         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool LN= (no value)" >&5
8517 $as_echo "$as_me: Setting user supplied tool LN= (no value)" >&6;}
8518         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LN" >&5
8519 $as_echo_n "checking for LN... " >&6; }
8520         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
8521 $as_echo "disabled" >&6; }
8522       else
8523         # Check if the provided tool contains a complete path.
8524         tool_specified="$LN"
8525         tool_basename="${tool_specified##*/}"
8526         if test "x$tool_basename" = "x$tool_specified"; then
8527           # A command without a complete path is provided, search $PATH.
8528           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LN=$tool_basename" >&5
8529 $as_echo "$as_me: Will search for user supplied tool LN=$tool_basename" >&6;}
8530           # Extract the first word of "$tool_basename", so it can be a program name with args.
8531 set dummy $tool_basename; ac_word=$2
8532 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8533 $as_echo_n "checking for $ac_word... " >&6; }
8534 if ${ac_cv_path_LN+:} false; then :
8535   $as_echo_n "(cached) " >&6
8536 else
8537   case $LN in
8538   [\\/]* | ?:[\\/]*)
8539   ac_cv_path_LN="$LN" # Let the user override the test with a path.
8540   ;;
8541   *)
8542   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8543 for as_dir in $PATH
8544 do
8545   IFS=$as_save_IFS
8546   test -z "$as_dir" && as_dir=.
8547     for ac_exec_ext in '' $ac_executable_extensions; do
8548   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8549     ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
8550     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8551     break 2
8552   fi
8553 done
8554   done
8555 IFS=$as_save_IFS
8556 
8557   ;;
8558 esac
8559 fi
8560 LN=$ac_cv_path_LN
8561 if test -n "$LN"; then
8562   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
8563 $as_echo "$LN" >&6; }
8564 else
8565   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8566 $as_echo "no" >&6; }
8567 fi
8568 
8569 
8570           if test "x$LN" = x; then
8571             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8572           fi
8573         else
8574           # Otherwise we believe it is a complete path. Use it as it is.
8575           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LN=$tool_specified" >&5
8576 $as_echo "$as_me: Will use user supplied tool LN=$tool_specified" >&6;}
8577           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LN" >&5
8578 $as_echo_n "checking for LN... " >&6; }
8579           if test ! -x "$tool_specified"; then
8580             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8581 $as_echo "not found" >&6; }
8582             as_fn_error $? "User supplied tool LN=$tool_specified does not exist or is not executable" "$LINENO" 5
8583           fi
8584           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8585 $as_echo "$tool_specified" >&6; }
8586         fi
8587       fi
8588     fi
8589 
8590   fi
8591 
8592 
8593 
8594   if test "x$LN" = x; then
8595     as_fn_error $? "Could not find required tool for LN" "$LINENO" 5
8596   fi
8597 
8598 
8599 
8600 
8601 
8602   # Publish this variable in the help.
8603 
8604 
8605   if [ -z "${LS+x}" ]; then
8606     # The variable is not set by user, try to locate tool using the code snippet
8607     for ac_prog in ls
8608 do
8609   # Extract the first word of "$ac_prog", so it can be a program name with args.
8610 set dummy $ac_prog; ac_word=$2
8611 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8612 $as_echo_n "checking for $ac_word... " >&6; }
8613 if ${ac_cv_path_LS+:} false; then :
8614   $as_echo_n "(cached) " >&6
8615 else
8616   case $LS in
8617   [\\/]* | ?:[\\/]*)
8618   ac_cv_path_LS="$LS" # Let the user override the test with a path.
8619   ;;
8620   *)
8621   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8622 for as_dir in $PATH
8623 do
8624   IFS=$as_save_IFS
8625   test -z "$as_dir" && as_dir=.
8626     for ac_exec_ext in '' $ac_executable_extensions; do
8627   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8628     ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
8629     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8630     break 2
8631   fi
8632 done
8633   done
8634 IFS=$as_save_IFS
8635 
8636   ;;
8637 esac
8638 fi
8639 LS=$ac_cv_path_LS
8640 if test -n "$LS"; then
8641   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
8642 $as_echo "$LS" >&6; }
8643 else
8644   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8645 $as_echo "no" >&6; }
8646 fi
8647 
8648 
8649   test -n "$LS" && break
8650 done
8651 
8652   else
8653     # The variable is set, but is it from the command line or the environment?
8654 
8655     # Try to remove the string !LS! from our list.
8656     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LS!/}
8657     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8658       # If it failed, the variable was not from the command line. Ignore it,
8659       # but warn the user (except for BASH, which is always set by the calling BASH).
8660       if test "xLS" != xBASH; then
8661         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LS from the environment. Use command line variables instead." >&5
8662 $as_echo "$as_me: WARNING: Ignoring value of LS from the environment. Use command line variables instead." >&2;}
8663       fi
8664       # Try to locate tool using the code snippet
8665       for ac_prog in ls
8666 do
8667   # Extract the first word of "$ac_prog", so it can be a program name with args.
8668 set dummy $ac_prog; ac_word=$2
8669 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8670 $as_echo_n "checking for $ac_word... " >&6; }
8671 if ${ac_cv_path_LS+:} false; then :
8672   $as_echo_n "(cached) " >&6
8673 else
8674   case $LS in
8675   [\\/]* | ?:[\\/]*)
8676   ac_cv_path_LS="$LS" # Let the user override the test with a path.
8677   ;;
8678   *)
8679   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8680 for as_dir in $PATH
8681 do
8682   IFS=$as_save_IFS
8683   test -z "$as_dir" && as_dir=.
8684     for ac_exec_ext in '' $ac_executable_extensions; do
8685   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8686     ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
8687     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8688     break 2
8689   fi
8690 done
8691   done
8692 IFS=$as_save_IFS
8693 
8694   ;;
8695 esac
8696 fi
8697 LS=$ac_cv_path_LS
8698 if test -n "$LS"; then
8699   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
8700 $as_echo "$LS" >&6; }
8701 else
8702   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8703 $as_echo "no" >&6; }
8704 fi
8705 
8706 
8707   test -n "$LS" && break
8708 done
8709 
8710     else
8711       # If it succeeded, then it was overridden by the user. We will use it
8712       # for the tool.
8713 
8714       # First remove it from the list of overridden variables, so we can test
8715       # for unknown variables in the end.
8716       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8717 
8718       # Check if we try to supply an empty value
8719       if test "x$LS" = x; then
8720         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool LS= (no value)" >&5
8721 $as_echo "$as_me: Setting user supplied tool LS= (no value)" >&6;}
8722         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LS" >&5
8723 $as_echo_n "checking for LS... " >&6; }
8724         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
8725 $as_echo "disabled" >&6; }
8726       else
8727         # Check if the provided tool contains a complete path.
8728         tool_specified="$LS"
8729         tool_basename="${tool_specified##*/}"
8730         if test "x$tool_basename" = "x$tool_specified"; then
8731           # A command without a complete path is provided, search $PATH.
8732           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LS=$tool_basename" >&5
8733 $as_echo "$as_me: Will search for user supplied tool LS=$tool_basename" >&6;}
8734           # Extract the first word of "$tool_basename", so it can be a program name with args.
8735 set dummy $tool_basename; ac_word=$2
8736 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8737 $as_echo_n "checking for $ac_word... " >&6; }
8738 if ${ac_cv_path_LS+:} false; then :
8739   $as_echo_n "(cached) " >&6
8740 else
8741   case $LS in
8742   [\\/]* | ?:[\\/]*)
8743   ac_cv_path_LS="$LS" # Let the user override the test with a path.
8744   ;;
8745   *)
8746   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8747 for as_dir in $PATH
8748 do
8749   IFS=$as_save_IFS
8750   test -z "$as_dir" && as_dir=.
8751     for ac_exec_ext in '' $ac_executable_extensions; do
8752   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8753     ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
8754     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8755     break 2
8756   fi
8757 done
8758   done
8759 IFS=$as_save_IFS
8760 
8761   ;;
8762 esac
8763 fi
8764 LS=$ac_cv_path_LS
8765 if test -n "$LS"; then
8766   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
8767 $as_echo "$LS" >&6; }
8768 else
8769   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8770 $as_echo "no" >&6; }
8771 fi
8772 
8773 
8774           if test "x$LS" = x; then
8775             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8776           fi
8777         else
8778           # Otherwise we believe it is a complete path. Use it as it is.
8779           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LS=$tool_specified" >&5
8780 $as_echo "$as_me: Will use user supplied tool LS=$tool_specified" >&6;}
8781           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LS" >&5
8782 $as_echo_n "checking for LS... " >&6; }
8783           if test ! -x "$tool_specified"; then
8784             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8785 $as_echo "not found" >&6; }
8786             as_fn_error $? "User supplied tool LS=$tool_specified does not exist or is not executable" "$LINENO" 5
8787           fi
8788           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8789 $as_echo "$tool_specified" >&6; }
8790         fi
8791       fi
8792     fi
8793 
8794   fi
8795 
8796 
8797 
8798   if test "x$LS" = x; then
8799     as_fn_error $? "Could not find required tool for LS" "$LINENO" 5
8800   fi
8801 
8802 
8803 
8804 
8805 
8806   # Publish this variable in the help.
8807 
8808 
8809   if [ -z "${MKDIR+x}" ]; then
8810     # The variable is not set by user, try to locate tool using the code snippet
8811     for ac_prog in mkdir
8812 do
8813   # Extract the first word of "$ac_prog", so it can be a program name with args.
8814 set dummy $ac_prog; ac_word=$2
8815 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8816 $as_echo_n "checking for $ac_word... " >&6; }
8817 if ${ac_cv_path_MKDIR+:} false; then :
8818   $as_echo_n "(cached) " >&6
8819 else
8820   case $MKDIR in
8821   [\\/]* | ?:[\\/]*)
8822   ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
8823   ;;
8824   *)
8825   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8826 for as_dir in $PATH
8827 do
8828   IFS=$as_save_IFS
8829   test -z "$as_dir" && as_dir=.
8830     for ac_exec_ext in '' $ac_executable_extensions; do
8831   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8832     ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
8833     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8834     break 2
8835   fi
8836 done
8837   done
8838 IFS=$as_save_IFS
8839 
8840   ;;
8841 esac
8842 fi
8843 MKDIR=$ac_cv_path_MKDIR
8844 if test -n "$MKDIR"; then
8845   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
8846 $as_echo "$MKDIR" >&6; }
8847 else
8848   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8849 $as_echo "no" >&6; }
8850 fi
8851 
8852 
8853   test -n "$MKDIR" && break
8854 done
8855 
8856   else
8857     # The variable is set, but is it from the command line or the environment?
8858 
8859     # Try to remove the string !MKDIR! from our list.
8860     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MKDIR!/}
8861     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8862       # If it failed, the variable was not from the command line. Ignore it,
8863       # but warn the user (except for BASH, which is always set by the calling BASH).
8864       if test "xMKDIR" != xBASH; then
8865         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MKDIR from the environment. Use command line variables instead." >&5
8866 $as_echo "$as_me: WARNING: Ignoring value of MKDIR from the environment. Use command line variables instead." >&2;}
8867       fi
8868       # Try to locate tool using the code snippet
8869       for ac_prog in mkdir
8870 do
8871   # Extract the first word of "$ac_prog", so it can be a program name with args.
8872 set dummy $ac_prog; ac_word=$2
8873 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8874 $as_echo_n "checking for $ac_word... " >&6; }
8875 if ${ac_cv_path_MKDIR+:} false; then :
8876   $as_echo_n "(cached) " >&6
8877 else
8878   case $MKDIR in
8879   [\\/]* | ?:[\\/]*)
8880   ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
8881   ;;
8882   *)
8883   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8884 for as_dir in $PATH
8885 do
8886   IFS=$as_save_IFS
8887   test -z "$as_dir" && as_dir=.
8888     for ac_exec_ext in '' $ac_executable_extensions; do
8889   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8890     ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
8891     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8892     break 2
8893   fi
8894 done
8895   done
8896 IFS=$as_save_IFS
8897 
8898   ;;
8899 esac
8900 fi
8901 MKDIR=$ac_cv_path_MKDIR
8902 if test -n "$MKDIR"; then
8903   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
8904 $as_echo "$MKDIR" >&6; }
8905 else
8906   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8907 $as_echo "no" >&6; }
8908 fi
8909 
8910 
8911   test -n "$MKDIR" && break
8912 done
8913 
8914     else
8915       # If it succeeded, then it was overridden by the user. We will use it
8916       # for the tool.
8917 
8918       # First remove it from the list of overridden variables, so we can test
8919       # for unknown variables in the end.
8920       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8921 
8922       # Check if we try to supply an empty value
8923       if test "x$MKDIR" = x; then
8924         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool MKDIR= (no value)" >&5
8925 $as_echo "$as_me: Setting user supplied tool MKDIR= (no value)" >&6;}
8926         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKDIR" >&5
8927 $as_echo_n "checking for MKDIR... " >&6; }
8928         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
8929 $as_echo "disabled" >&6; }
8930       else
8931         # Check if the provided tool contains a complete path.
8932         tool_specified="$MKDIR"
8933         tool_basename="${tool_specified##*/}"
8934         if test "x$tool_basename" = "x$tool_specified"; then
8935           # A command without a complete path is provided, search $PATH.
8936           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MKDIR=$tool_basename" >&5
8937 $as_echo "$as_me: Will search for user supplied tool MKDIR=$tool_basename" >&6;}
8938           # Extract the first word of "$tool_basename", so it can be a program name with args.
8939 set dummy $tool_basename; ac_word=$2
8940 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8941 $as_echo_n "checking for $ac_word... " >&6; }
8942 if ${ac_cv_path_MKDIR+:} false; then :
8943   $as_echo_n "(cached) " >&6
8944 else
8945   case $MKDIR in
8946   [\\/]* | ?:[\\/]*)
8947   ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
8948   ;;
8949   *)
8950   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8951 for as_dir in $PATH
8952 do
8953   IFS=$as_save_IFS
8954   test -z "$as_dir" && as_dir=.
8955     for ac_exec_ext in '' $ac_executable_extensions; do
8956   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8957     ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
8958     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8959     break 2
8960   fi
8961 done
8962   done
8963 IFS=$as_save_IFS
8964 
8965   ;;
8966 esac
8967 fi
8968 MKDIR=$ac_cv_path_MKDIR
8969 if test -n "$MKDIR"; then
8970   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
8971 $as_echo "$MKDIR" >&6; }
8972 else
8973   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8974 $as_echo "no" >&6; }
8975 fi
8976 
8977 
8978           if test "x$MKDIR" = x; then
8979             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8980           fi
8981         else
8982           # Otherwise we believe it is a complete path. Use it as it is.
8983           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MKDIR=$tool_specified" >&5
8984 $as_echo "$as_me: Will use user supplied tool MKDIR=$tool_specified" >&6;}
8985           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKDIR" >&5
8986 $as_echo_n "checking for MKDIR... " >&6; }
8987           if test ! -x "$tool_specified"; then
8988             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8989 $as_echo "not found" >&6; }
8990             as_fn_error $? "User supplied tool MKDIR=$tool_specified does not exist or is not executable" "$LINENO" 5
8991           fi
8992           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8993 $as_echo "$tool_specified" >&6; }
8994         fi
8995       fi
8996     fi
8997 
8998   fi
8999 
9000 
9001 
9002   if test "x$MKDIR" = x; then
9003     as_fn_error $? "Could not find required tool for MKDIR" "$LINENO" 5
9004   fi
9005 
9006 
9007 
9008 
9009 
9010   # Publish this variable in the help.
9011 
9012 
9013   if [ -z "${MKTEMP+x}" ]; then
9014     # The variable is not set by user, try to locate tool using the code snippet
9015     for ac_prog in mktemp
9016 do
9017   # Extract the first word of "$ac_prog", so it can be a program name with args.
9018 set dummy $ac_prog; ac_word=$2
9019 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9020 $as_echo_n "checking for $ac_word... " >&6; }
9021 if ${ac_cv_path_MKTEMP+:} false; then :
9022   $as_echo_n "(cached) " >&6
9023 else
9024   case $MKTEMP in
9025   [\\/]* | ?:[\\/]*)
9026   ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
9027   ;;
9028   *)
9029   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9030 for as_dir in $PATH
9031 do
9032   IFS=$as_save_IFS
9033   test -z "$as_dir" && as_dir=.
9034     for ac_exec_ext in '' $ac_executable_extensions; do
9035   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9036     ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
9037     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9038     break 2
9039   fi
9040 done
9041   done
9042 IFS=$as_save_IFS
9043 
9044   ;;
9045 esac
9046 fi
9047 MKTEMP=$ac_cv_path_MKTEMP
9048 if test -n "$MKTEMP"; then
9049   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
9050 $as_echo "$MKTEMP" >&6; }
9051 else
9052   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9053 $as_echo "no" >&6; }
9054 fi
9055 
9056 
9057   test -n "$MKTEMP" && break
9058 done
9059 
9060   else
9061     # The variable is set, but is it from the command line or the environment?
9062 
9063     # Try to remove the string !MKTEMP! from our list.
9064     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MKTEMP!/}
9065     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9066       # If it failed, the variable was not from the command line. Ignore it,
9067       # but warn the user (except for BASH, which is always set by the calling BASH).
9068       if test "xMKTEMP" != xBASH; then
9069         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MKTEMP from the environment. Use command line variables instead." >&5
9070 $as_echo "$as_me: WARNING: Ignoring value of MKTEMP from the environment. Use command line variables instead." >&2;}
9071       fi
9072       # Try to locate tool using the code snippet
9073       for ac_prog in mktemp
9074 do
9075   # Extract the first word of "$ac_prog", so it can be a program name with args.
9076 set dummy $ac_prog; ac_word=$2
9077 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9078 $as_echo_n "checking for $ac_word... " >&6; }
9079 if ${ac_cv_path_MKTEMP+:} false; then :
9080   $as_echo_n "(cached) " >&6
9081 else
9082   case $MKTEMP in
9083   [\\/]* | ?:[\\/]*)
9084   ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
9085   ;;
9086   *)
9087   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9088 for as_dir in $PATH
9089 do
9090   IFS=$as_save_IFS
9091   test -z "$as_dir" && as_dir=.
9092     for ac_exec_ext in '' $ac_executable_extensions; do
9093   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9094     ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
9095     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9096     break 2
9097   fi
9098 done
9099   done
9100 IFS=$as_save_IFS
9101 
9102   ;;
9103 esac
9104 fi
9105 MKTEMP=$ac_cv_path_MKTEMP
9106 if test -n "$MKTEMP"; then
9107   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
9108 $as_echo "$MKTEMP" >&6; }
9109 else
9110   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9111 $as_echo "no" >&6; }
9112 fi
9113 
9114 
9115   test -n "$MKTEMP" && break
9116 done
9117 
9118     else
9119       # If it succeeded, then it was overridden by the user. We will use it
9120       # for the tool.
9121 
9122       # First remove it from the list of overridden variables, so we can test
9123       # for unknown variables in the end.
9124       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9125 
9126       # Check if we try to supply an empty value
9127       if test "x$MKTEMP" = x; then
9128         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool MKTEMP= (no value)" >&5
9129 $as_echo "$as_me: Setting user supplied tool MKTEMP= (no value)" >&6;}
9130         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKTEMP" >&5
9131 $as_echo_n "checking for MKTEMP... " >&6; }
9132         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
9133 $as_echo "disabled" >&6; }
9134       else
9135         # Check if the provided tool contains a complete path.
9136         tool_specified="$MKTEMP"
9137         tool_basename="${tool_specified##*/}"
9138         if test "x$tool_basename" = "x$tool_specified"; then
9139           # A command without a complete path is provided, search $PATH.
9140           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MKTEMP=$tool_basename" >&5
9141 $as_echo "$as_me: Will search for user supplied tool MKTEMP=$tool_basename" >&6;}
9142           # Extract the first word of "$tool_basename", so it can be a program name with args.
9143 set dummy $tool_basename; ac_word=$2
9144 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9145 $as_echo_n "checking for $ac_word... " >&6; }
9146 if ${ac_cv_path_MKTEMP+:} false; then :
9147   $as_echo_n "(cached) " >&6
9148 else
9149   case $MKTEMP in
9150   [\\/]* | ?:[\\/]*)
9151   ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
9152   ;;
9153   *)
9154   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9155 for as_dir in $PATH
9156 do
9157   IFS=$as_save_IFS
9158   test -z "$as_dir" && as_dir=.
9159     for ac_exec_ext in '' $ac_executable_extensions; do
9160   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9161     ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
9162     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9163     break 2
9164   fi
9165 done
9166   done
9167 IFS=$as_save_IFS
9168 
9169   ;;
9170 esac
9171 fi
9172 MKTEMP=$ac_cv_path_MKTEMP
9173 if test -n "$MKTEMP"; then
9174   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
9175 $as_echo "$MKTEMP" >&6; }
9176 else
9177   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9178 $as_echo "no" >&6; }
9179 fi
9180 
9181 
9182           if test "x$MKTEMP" = x; then
9183             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9184           fi
9185         else
9186           # Otherwise we believe it is a complete path. Use it as it is.
9187           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MKTEMP=$tool_specified" >&5
9188 $as_echo "$as_me: Will use user supplied tool MKTEMP=$tool_specified" >&6;}
9189           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKTEMP" >&5
9190 $as_echo_n "checking for MKTEMP... " >&6; }
9191           if test ! -x "$tool_specified"; then
9192             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9193 $as_echo "not found" >&6; }
9194             as_fn_error $? "User supplied tool MKTEMP=$tool_specified does not exist or is not executable" "$LINENO" 5
9195           fi
9196           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9197 $as_echo "$tool_specified" >&6; }
9198         fi
9199       fi
9200     fi
9201 
9202   fi
9203 
9204 
9205 
9206   if test "x$MKTEMP" = x; then
9207     as_fn_error $? "Could not find required tool for MKTEMP" "$LINENO" 5
9208   fi
9209 
9210 
9211 
9212 
9213 
9214   # Publish this variable in the help.
9215 
9216 
9217   if [ -z "${MV+x}" ]; then
9218     # The variable is not set by user, try to locate tool using the code snippet
9219     for ac_prog in mv
9220 do
9221   # Extract the first word of "$ac_prog", so it can be a program name with args.
9222 set dummy $ac_prog; ac_word=$2
9223 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9224 $as_echo_n "checking for $ac_word... " >&6; }
9225 if ${ac_cv_path_MV+:} false; then :
9226   $as_echo_n "(cached) " >&6
9227 else
9228   case $MV in
9229   [\\/]* | ?:[\\/]*)
9230   ac_cv_path_MV="$MV" # Let the user override the test with a path.
9231   ;;
9232   *)
9233   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9234 for as_dir in $PATH
9235 do
9236   IFS=$as_save_IFS
9237   test -z "$as_dir" && as_dir=.
9238     for ac_exec_ext in '' $ac_executable_extensions; do
9239   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9240     ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
9241     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9242     break 2
9243   fi
9244 done
9245   done
9246 IFS=$as_save_IFS
9247 
9248   ;;
9249 esac
9250 fi
9251 MV=$ac_cv_path_MV
9252 if test -n "$MV"; then
9253   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
9254 $as_echo "$MV" >&6; }
9255 else
9256   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9257 $as_echo "no" >&6; }
9258 fi
9259 
9260 
9261   test -n "$MV" && break
9262 done
9263 
9264   else
9265     # The variable is set, but is it from the command line or the environment?
9266 
9267     # Try to remove the string !MV! from our list.
9268     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MV!/}
9269     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9270       # If it failed, the variable was not from the command line. Ignore it,
9271       # but warn the user (except for BASH, which is always set by the calling BASH).
9272       if test "xMV" != xBASH; then
9273         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MV from the environment. Use command line variables instead." >&5
9274 $as_echo "$as_me: WARNING: Ignoring value of MV from the environment. Use command line variables instead." >&2;}
9275       fi
9276       # Try to locate tool using the code snippet
9277       for ac_prog in mv
9278 do
9279   # Extract the first word of "$ac_prog", so it can be a program name with args.
9280 set dummy $ac_prog; ac_word=$2
9281 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9282 $as_echo_n "checking for $ac_word... " >&6; }
9283 if ${ac_cv_path_MV+:} false; then :
9284   $as_echo_n "(cached) " >&6
9285 else
9286   case $MV in
9287   [\\/]* | ?:[\\/]*)
9288   ac_cv_path_MV="$MV" # Let the user override the test with a path.
9289   ;;
9290   *)
9291   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9292 for as_dir in $PATH
9293 do
9294   IFS=$as_save_IFS
9295   test -z "$as_dir" && as_dir=.
9296     for ac_exec_ext in '' $ac_executable_extensions; do
9297   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9298     ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
9299     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9300     break 2
9301   fi
9302 done
9303   done
9304 IFS=$as_save_IFS
9305 
9306   ;;
9307 esac
9308 fi
9309 MV=$ac_cv_path_MV
9310 if test -n "$MV"; then
9311   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
9312 $as_echo "$MV" >&6; }
9313 else
9314   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9315 $as_echo "no" >&6; }
9316 fi
9317 
9318 
9319   test -n "$MV" && break
9320 done
9321 
9322     else
9323       # If it succeeded, then it was overridden by the user. We will use it
9324       # for the tool.
9325 
9326       # First remove it from the list of overridden variables, so we can test
9327       # for unknown variables in the end.
9328       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9329 
9330       # Check if we try to supply an empty value
9331       if test "x$MV" = x; then
9332         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool MV= (no value)" >&5
9333 $as_echo "$as_me: Setting user supplied tool MV= (no value)" >&6;}
9334         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MV" >&5
9335 $as_echo_n "checking for MV... " >&6; }
9336         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
9337 $as_echo "disabled" >&6; }
9338       else
9339         # Check if the provided tool contains a complete path.
9340         tool_specified="$MV"
9341         tool_basename="${tool_specified##*/}"
9342         if test "x$tool_basename" = "x$tool_specified"; then
9343           # A command without a complete path is provided, search $PATH.
9344           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MV=$tool_basename" >&5
9345 $as_echo "$as_me: Will search for user supplied tool MV=$tool_basename" >&6;}
9346           # Extract the first word of "$tool_basename", so it can be a program name with args.
9347 set dummy $tool_basename; ac_word=$2
9348 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9349 $as_echo_n "checking for $ac_word... " >&6; }
9350 if ${ac_cv_path_MV+:} false; then :
9351   $as_echo_n "(cached) " >&6
9352 else
9353   case $MV in
9354   [\\/]* | ?:[\\/]*)
9355   ac_cv_path_MV="$MV" # Let the user override the test with a path.
9356   ;;
9357   *)
9358   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9359 for as_dir in $PATH
9360 do
9361   IFS=$as_save_IFS
9362   test -z "$as_dir" && as_dir=.
9363     for ac_exec_ext in '' $ac_executable_extensions; do
9364   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9365     ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
9366     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9367     break 2
9368   fi
9369 done
9370   done
9371 IFS=$as_save_IFS
9372 
9373   ;;
9374 esac
9375 fi
9376 MV=$ac_cv_path_MV
9377 if test -n "$MV"; then
9378   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
9379 $as_echo "$MV" >&6; }
9380 else
9381   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9382 $as_echo "no" >&6; }
9383 fi
9384 
9385 
9386           if test "x$MV" = x; then
9387             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9388           fi
9389         else
9390           # Otherwise we believe it is a complete path. Use it as it is.
9391           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MV=$tool_specified" >&5
9392 $as_echo "$as_me: Will use user supplied tool MV=$tool_specified" >&6;}
9393           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MV" >&5
9394 $as_echo_n "checking for MV... " >&6; }
9395           if test ! -x "$tool_specified"; then
9396             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9397 $as_echo "not found" >&6; }
9398             as_fn_error $? "User supplied tool MV=$tool_specified does not exist or is not executable" "$LINENO" 5
9399           fi
9400           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9401 $as_echo "$tool_specified" >&6; }
9402         fi
9403       fi
9404     fi
9405 
9406   fi
9407 
9408 
9409 
9410   if test "x$MV" = x; then
9411     as_fn_error $? "Could not find required tool for MV" "$LINENO" 5
9412   fi
9413 
9414 
9415 
9416 
9417 
9418   # Publish this variable in the help.
9419 
9420 
9421   if [ -z "${NAWK+x}" ]; then
9422     # The variable is not set by user, try to locate tool using the code snippet
9423     for ac_prog in nawk gawk awk
9424 do
9425   # Extract the first word of "$ac_prog", so it can be a program name with args.
9426 set dummy $ac_prog; ac_word=$2
9427 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9428 $as_echo_n "checking for $ac_word... " >&6; }
9429 if ${ac_cv_path_NAWK+:} false; then :
9430   $as_echo_n "(cached) " >&6
9431 else
9432   case $NAWK in
9433   [\\/]* | ?:[\\/]*)
9434   ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
9435   ;;
9436   *)
9437   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9438 for as_dir in $PATH
9439 do
9440   IFS=$as_save_IFS
9441   test -z "$as_dir" && as_dir=.
9442     for ac_exec_ext in '' $ac_executable_extensions; do
9443   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9444     ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
9445     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9446     break 2
9447   fi
9448 done
9449   done
9450 IFS=$as_save_IFS
9451 
9452   ;;
9453 esac
9454 fi
9455 NAWK=$ac_cv_path_NAWK
9456 if test -n "$NAWK"; then
9457   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
9458 $as_echo "$NAWK" >&6; }
9459 else
9460   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9461 $as_echo "no" >&6; }
9462 fi
9463 
9464 
9465   test -n "$NAWK" && break
9466 done
9467 
9468   else
9469     # The variable is set, but is it from the command line or the environment?
9470 
9471     # Try to remove the string !NAWK! from our list.
9472     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!NAWK!/}
9473     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9474       # If it failed, the variable was not from the command line. Ignore it,
9475       # but warn the user (except for BASH, which is always set by the calling BASH).
9476       if test "xNAWK" != xBASH; then
9477         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of NAWK from the environment. Use command line variables instead." >&5
9478 $as_echo "$as_me: WARNING: Ignoring value of NAWK from the environment. Use command line variables instead." >&2;}
9479       fi
9480       # Try to locate tool using the code snippet
9481       for ac_prog in nawk gawk awk
9482 do
9483   # Extract the first word of "$ac_prog", so it can be a program name with args.
9484 set dummy $ac_prog; ac_word=$2
9485 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9486 $as_echo_n "checking for $ac_word... " >&6; }
9487 if ${ac_cv_path_NAWK+:} false; then :
9488   $as_echo_n "(cached) " >&6
9489 else
9490   case $NAWK in
9491   [\\/]* | ?:[\\/]*)
9492   ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
9493   ;;
9494   *)
9495   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9496 for as_dir in $PATH
9497 do
9498   IFS=$as_save_IFS
9499   test -z "$as_dir" && as_dir=.
9500     for ac_exec_ext in '' $ac_executable_extensions; do
9501   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9502     ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
9503     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9504     break 2
9505   fi
9506 done
9507   done
9508 IFS=$as_save_IFS
9509 
9510   ;;
9511 esac
9512 fi
9513 NAWK=$ac_cv_path_NAWK
9514 if test -n "$NAWK"; then
9515   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
9516 $as_echo "$NAWK" >&6; }
9517 else
9518   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9519 $as_echo "no" >&6; }
9520 fi
9521 
9522 
9523   test -n "$NAWK" && break
9524 done
9525 
9526     else
9527       # If it succeeded, then it was overridden by the user. We will use it
9528       # for the tool.
9529 
9530       # First remove it from the list of overridden variables, so we can test
9531       # for unknown variables in the end.
9532       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9533 
9534       # Check if we try to supply an empty value
9535       if test "x$NAWK" = x; then
9536         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool NAWK= (no value)" >&5
9537 $as_echo "$as_me: Setting user supplied tool NAWK= (no value)" >&6;}
9538         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NAWK" >&5
9539 $as_echo_n "checking for NAWK... " >&6; }
9540         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
9541 $as_echo "disabled" >&6; }
9542       else
9543         # Check if the provided tool contains a complete path.
9544         tool_specified="$NAWK"
9545         tool_basename="${tool_specified##*/}"
9546         if test "x$tool_basename" = "x$tool_specified"; then
9547           # A command without a complete path is provided, search $PATH.
9548           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool NAWK=$tool_basename" >&5
9549 $as_echo "$as_me: Will search for user supplied tool NAWK=$tool_basename" >&6;}
9550           # Extract the first word of "$tool_basename", so it can be a program name with args.
9551 set dummy $tool_basename; ac_word=$2
9552 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9553 $as_echo_n "checking for $ac_word... " >&6; }
9554 if ${ac_cv_path_NAWK+:} false; then :
9555   $as_echo_n "(cached) " >&6
9556 else
9557   case $NAWK in
9558   [\\/]* | ?:[\\/]*)
9559   ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
9560   ;;
9561   *)
9562   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9563 for as_dir in $PATH
9564 do
9565   IFS=$as_save_IFS
9566   test -z "$as_dir" && as_dir=.
9567     for ac_exec_ext in '' $ac_executable_extensions; do
9568   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9569     ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
9570     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9571     break 2
9572   fi
9573 done
9574   done
9575 IFS=$as_save_IFS
9576 
9577   ;;
9578 esac
9579 fi
9580 NAWK=$ac_cv_path_NAWK
9581 if test -n "$NAWK"; then
9582   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
9583 $as_echo "$NAWK" >&6; }
9584 else
9585   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9586 $as_echo "no" >&6; }
9587 fi
9588 
9589 
9590           if test "x$NAWK" = x; then
9591             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9592           fi
9593         else
9594           # Otherwise we believe it is a complete path. Use it as it is.
9595           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool NAWK=$tool_specified" >&5
9596 $as_echo "$as_me: Will use user supplied tool NAWK=$tool_specified" >&6;}
9597           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NAWK" >&5
9598 $as_echo_n "checking for NAWK... " >&6; }
9599           if test ! -x "$tool_specified"; then
9600             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9601 $as_echo "not found" >&6; }
9602             as_fn_error $? "User supplied tool NAWK=$tool_specified does not exist or is not executable" "$LINENO" 5
9603           fi
9604           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9605 $as_echo "$tool_specified" >&6; }
9606         fi
9607       fi
9608     fi
9609 
9610   fi
9611 
9612 
9613 
9614   if test "x$NAWK" = x; then
9615     as_fn_error $? "Could not find required tool for NAWK" "$LINENO" 5
9616   fi
9617 
9618 
9619 
9620 
9621 
9622   # Publish this variable in the help.
9623 
9624 
9625   if [ -z "${PRINTF+x}" ]; then
9626     # The variable is not set by user, try to locate tool using the code snippet
9627     for ac_prog in printf
9628 do
9629   # Extract the first word of "$ac_prog", so it can be a program name with args.
9630 set dummy $ac_prog; ac_word=$2
9631 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9632 $as_echo_n "checking for $ac_word... " >&6; }
9633 if ${ac_cv_path_PRINTF+:} false; then :
9634   $as_echo_n "(cached) " >&6
9635 else
9636   case $PRINTF in
9637   [\\/]* | ?:[\\/]*)
9638   ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
9639   ;;
9640   *)
9641   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9642 for as_dir in $PATH
9643 do
9644   IFS=$as_save_IFS
9645   test -z "$as_dir" && as_dir=.
9646     for ac_exec_ext in '' $ac_executable_extensions; do
9647   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9648     ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
9649     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9650     break 2
9651   fi
9652 done
9653   done
9654 IFS=$as_save_IFS
9655 
9656   ;;
9657 esac
9658 fi
9659 PRINTF=$ac_cv_path_PRINTF
9660 if test -n "$PRINTF"; then
9661   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
9662 $as_echo "$PRINTF" >&6; }
9663 else
9664   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9665 $as_echo "no" >&6; }
9666 fi
9667 
9668 
9669   test -n "$PRINTF" && break
9670 done
9671 
9672   else
9673     # The variable is set, but is it from the command line or the environment?
9674 
9675     # Try to remove the string !PRINTF! from our list.
9676     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!PRINTF!/}
9677     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9678       # If it failed, the variable was not from the command line. Ignore it,
9679       # but warn the user (except for BASH, which is always set by the calling BASH).
9680       if test "xPRINTF" != xBASH; then
9681         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of PRINTF from the environment. Use command line variables instead." >&5
9682 $as_echo "$as_me: WARNING: Ignoring value of PRINTF from the environment. Use command line variables instead." >&2;}
9683       fi
9684       # Try to locate tool using the code snippet
9685       for ac_prog in printf
9686 do
9687   # Extract the first word of "$ac_prog", so it can be a program name with args.
9688 set dummy $ac_prog; ac_word=$2
9689 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9690 $as_echo_n "checking for $ac_word... " >&6; }
9691 if ${ac_cv_path_PRINTF+:} false; then :
9692   $as_echo_n "(cached) " >&6
9693 else
9694   case $PRINTF in
9695   [\\/]* | ?:[\\/]*)
9696   ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
9697   ;;
9698   *)
9699   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9700 for as_dir in $PATH
9701 do
9702   IFS=$as_save_IFS
9703   test -z "$as_dir" && as_dir=.
9704     for ac_exec_ext in '' $ac_executable_extensions; do
9705   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9706     ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
9707     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9708     break 2
9709   fi
9710 done
9711   done
9712 IFS=$as_save_IFS
9713 
9714   ;;
9715 esac
9716 fi
9717 PRINTF=$ac_cv_path_PRINTF
9718 if test -n "$PRINTF"; then
9719   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
9720 $as_echo "$PRINTF" >&6; }
9721 else
9722   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9723 $as_echo "no" >&6; }
9724 fi
9725 
9726 
9727   test -n "$PRINTF" && break
9728 done
9729 
9730     else
9731       # If it succeeded, then it was overridden by the user. We will use it
9732       # for the tool.
9733 
9734       # First remove it from the list of overridden variables, so we can test
9735       # for unknown variables in the end.
9736       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9737 
9738       # Check if we try to supply an empty value
9739       if test "x$PRINTF" = x; then
9740         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool PRINTF= (no value)" >&5
9741 $as_echo "$as_me: Setting user supplied tool PRINTF= (no value)" >&6;}
9742         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PRINTF" >&5
9743 $as_echo_n "checking for PRINTF... " >&6; }
9744         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
9745 $as_echo "disabled" >&6; }
9746       else
9747         # Check if the provided tool contains a complete path.
9748         tool_specified="$PRINTF"
9749         tool_basename="${tool_specified##*/}"
9750         if test "x$tool_basename" = "x$tool_specified"; then
9751           # A command without a complete path is provided, search $PATH.
9752           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool PRINTF=$tool_basename" >&5
9753 $as_echo "$as_me: Will search for user supplied tool PRINTF=$tool_basename" >&6;}
9754           # Extract the first word of "$tool_basename", so it can be a program name with args.
9755 set dummy $tool_basename; ac_word=$2
9756 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9757 $as_echo_n "checking for $ac_word... " >&6; }
9758 if ${ac_cv_path_PRINTF+:} false; then :
9759   $as_echo_n "(cached) " >&6
9760 else
9761   case $PRINTF in
9762   [\\/]* | ?:[\\/]*)
9763   ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
9764   ;;
9765   *)
9766   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9767 for as_dir in $PATH
9768 do
9769   IFS=$as_save_IFS
9770   test -z "$as_dir" && as_dir=.
9771     for ac_exec_ext in '' $ac_executable_extensions; do
9772   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9773     ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
9774     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9775     break 2
9776   fi
9777 done
9778   done
9779 IFS=$as_save_IFS
9780 
9781   ;;
9782 esac
9783 fi
9784 PRINTF=$ac_cv_path_PRINTF
9785 if test -n "$PRINTF"; then
9786   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
9787 $as_echo "$PRINTF" >&6; }
9788 else
9789   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9790 $as_echo "no" >&6; }
9791 fi
9792 
9793 
9794           if test "x$PRINTF" = x; then
9795             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9796           fi
9797         else
9798           # Otherwise we believe it is a complete path. Use it as it is.
9799           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool PRINTF=$tool_specified" >&5
9800 $as_echo "$as_me: Will use user supplied tool PRINTF=$tool_specified" >&6;}
9801           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PRINTF" >&5
9802 $as_echo_n "checking for PRINTF... " >&6; }
9803           if test ! -x "$tool_specified"; then
9804             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9805 $as_echo "not found" >&6; }
9806             as_fn_error $? "User supplied tool PRINTF=$tool_specified does not exist or is not executable" "$LINENO" 5
9807           fi
9808           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9809 $as_echo "$tool_specified" >&6; }
9810         fi
9811       fi
9812     fi
9813 
9814   fi
9815 
9816 
9817 
9818   if test "x$PRINTF" = x; then
9819     as_fn_error $? "Could not find required tool for PRINTF" "$LINENO" 5
9820   fi
9821 
9822 
9823 
9824 
9825 
9826   # Publish this variable in the help.
9827 
9828 
9829   if [ -z "${RM+x}" ]; then
9830     # The variable is not set by user, try to locate tool using the code snippet
9831     for ac_prog in rm
9832 do
9833   # Extract the first word of "$ac_prog", so it can be a program name with args.
9834 set dummy $ac_prog; ac_word=$2
9835 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9836 $as_echo_n "checking for $ac_word... " >&6; }
9837 if ${ac_cv_path_RM+:} false; then :
9838   $as_echo_n "(cached) " >&6
9839 else
9840   case $RM in
9841   [\\/]* | ?:[\\/]*)
9842   ac_cv_path_RM="$RM" # Let the user override the test with a path.
9843   ;;
9844   *)
9845   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9846 for as_dir in $PATH
9847 do
9848   IFS=$as_save_IFS
9849   test -z "$as_dir" && as_dir=.
9850     for ac_exec_ext in '' $ac_executable_extensions; do
9851   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9852     ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
9853     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9854     break 2
9855   fi
9856 done
9857   done
9858 IFS=$as_save_IFS
9859 
9860   ;;
9861 esac
9862 fi
9863 RM=$ac_cv_path_RM
9864 if test -n "$RM"; then
9865   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
9866 $as_echo "$RM" >&6; }
9867 else
9868   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9869 $as_echo "no" >&6; }
9870 fi
9871 
9872 
9873   test -n "$RM" && break
9874 done
9875 
9876   else
9877     # The variable is set, but is it from the command line or the environment?
9878 
9879     # Try to remove the string !RM! from our list.
9880     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!RM!/}
9881     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9882       # If it failed, the variable was not from the command line. Ignore it,
9883       # but warn the user (except for BASH, which is always set by the calling BASH).
9884       if test "xRM" != xBASH; then
9885         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of RM from the environment. Use command line variables instead." >&5
9886 $as_echo "$as_me: WARNING: Ignoring value of RM from the environment. Use command line variables instead." >&2;}
9887       fi
9888       # Try to locate tool using the code snippet
9889       for ac_prog in rm
9890 do
9891   # Extract the first word of "$ac_prog", so it can be a program name with args.
9892 set dummy $ac_prog; ac_word=$2
9893 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9894 $as_echo_n "checking for $ac_word... " >&6; }
9895 if ${ac_cv_path_RM+:} false; then :
9896   $as_echo_n "(cached) " >&6
9897 else
9898   case $RM in
9899   [\\/]* | ?:[\\/]*)
9900   ac_cv_path_RM="$RM" # Let the user override the test with a path.
9901   ;;
9902   *)
9903   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9904 for as_dir in $PATH
9905 do
9906   IFS=$as_save_IFS
9907   test -z "$as_dir" && as_dir=.
9908     for ac_exec_ext in '' $ac_executable_extensions; do
9909   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9910     ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
9911     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9912     break 2
9913   fi
9914 done
9915   done
9916 IFS=$as_save_IFS
9917 
9918   ;;
9919 esac
9920 fi
9921 RM=$ac_cv_path_RM
9922 if test -n "$RM"; then
9923   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
9924 $as_echo "$RM" >&6; }
9925 else
9926   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9927 $as_echo "no" >&6; }
9928 fi
9929 
9930 
9931   test -n "$RM" && break
9932 done
9933 
9934     else
9935       # If it succeeded, then it was overridden by the user. We will use it
9936       # for the tool.
9937 
9938       # First remove it from the list of overridden variables, so we can test
9939       # for unknown variables in the end.
9940       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9941 
9942       # Check if we try to supply an empty value
9943       if test "x$RM" = x; then
9944         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool RM= (no value)" >&5
9945 $as_echo "$as_me: Setting user supplied tool RM= (no value)" >&6;}
9946         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for RM" >&5
9947 $as_echo_n "checking for RM... " >&6; }
9948         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
9949 $as_echo "disabled" >&6; }
9950       else
9951         # Check if the provided tool contains a complete path.
9952         tool_specified="$RM"
9953         tool_basename="${tool_specified##*/}"
9954         if test "x$tool_basename" = "x$tool_specified"; then
9955           # A command without a complete path is provided, search $PATH.
9956           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool RM=$tool_basename" >&5
9957 $as_echo "$as_me: Will search for user supplied tool RM=$tool_basename" >&6;}
9958           # Extract the first word of "$tool_basename", so it can be a program name with args.
9959 set dummy $tool_basename; ac_word=$2
9960 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9961 $as_echo_n "checking for $ac_word... " >&6; }
9962 if ${ac_cv_path_RM+:} false; then :
9963   $as_echo_n "(cached) " >&6
9964 else
9965   case $RM in
9966   [\\/]* | ?:[\\/]*)
9967   ac_cv_path_RM="$RM" # Let the user override the test with a path.
9968   ;;
9969   *)
9970   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9971 for as_dir in $PATH
9972 do
9973   IFS=$as_save_IFS
9974   test -z "$as_dir" && as_dir=.
9975     for ac_exec_ext in '' $ac_executable_extensions; do
9976   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9977     ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
9978     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9979     break 2
9980   fi
9981 done
9982   done
9983 IFS=$as_save_IFS
9984 
9985   ;;
9986 esac
9987 fi
9988 RM=$ac_cv_path_RM
9989 if test -n "$RM"; then
9990   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
9991 $as_echo "$RM" >&6; }
9992 else
9993   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9994 $as_echo "no" >&6; }
9995 fi
9996 
9997 
9998           if test "x$RM" = x; then
9999             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10000           fi
10001         else
10002           # Otherwise we believe it is a complete path. Use it as it is.
10003           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool RM=$tool_specified" >&5
10004 $as_echo "$as_me: Will use user supplied tool RM=$tool_specified" >&6;}
10005           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for RM" >&5
10006 $as_echo_n "checking for RM... " >&6; }
10007           if test ! -x "$tool_specified"; then
10008             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10009 $as_echo "not found" >&6; }
10010             as_fn_error $? "User supplied tool RM=$tool_specified does not exist or is not executable" "$LINENO" 5
10011           fi
10012           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10013 $as_echo "$tool_specified" >&6; }
10014         fi
10015       fi
10016     fi
10017 
10018   fi
10019 
10020 
10021 
10022   if test "x$RM" = x; then
10023     as_fn_error $? "Could not find required tool for RM" "$LINENO" 5
10024   fi
10025 
10026 
10027 
10028 
10029 
10030   # Publish this variable in the help.
10031 
10032 
10033   if [ -z "${RMDIR+x}" ]; then
10034     # The variable is not set by user, try to locate tool using the code snippet
10035     for ac_prog in rmdir
10036 do
10037   # Extract the first word of "$ac_prog", so it can be a program name with args.
10038 set dummy $ac_prog; ac_word=$2
10039 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10040 $as_echo_n "checking for $ac_word... " >&6; }
10041 if ${ac_cv_path_RMDIR+:} false; then :
10042   $as_echo_n "(cached) " >&6
10043 else
10044   case $RMDIR in
10045   [\\/]* | ?:[\\/]*)
10046   ac_cv_path_RMDIR="$RMDIR" # Let the user override the test with a path.
10047   ;;
10048   *)
10049   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10050 for as_dir in $PATH
10051 do
10052   IFS=$as_save_IFS
10053   test -z "$as_dir" && as_dir=.
10054     for ac_exec_ext in '' $ac_executable_extensions; do
10055   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10056     ac_cv_path_RMDIR="$as_dir/$ac_word$ac_exec_ext"
10057     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10058     break 2
10059   fi
10060 done
10061   done
10062 IFS=$as_save_IFS
10063 
10064   ;;
10065 esac
10066 fi
10067 RMDIR=$ac_cv_path_RMDIR
10068 if test -n "$RMDIR"; then
10069   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RMDIR" >&5
10070 $as_echo "$RMDIR" >&6; }
10071 else
10072   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10073 $as_echo "no" >&6; }
10074 fi
10075 
10076 
10077   test -n "$RMDIR" && break
10078 done
10079 
10080   else
10081     # The variable is set, but is it from the command line or the environment?
10082 
10083     # Try to remove the string !RMDIR! from our list.
10084     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!RMDIR!/}
10085     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10086       # If it failed, the variable was not from the command line. Ignore it,
10087       # but warn the user (except for BASH, which is always set by the calling BASH).
10088       if test "xRMDIR" != xBASH; then
10089         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of RMDIR from the environment. Use command line variables instead." >&5
10090 $as_echo "$as_me: WARNING: Ignoring value of RMDIR from the environment. Use command line variables instead." >&2;}
10091       fi
10092       # Try to locate tool using the code snippet
10093       for ac_prog in rmdir
10094 do
10095   # Extract the first word of "$ac_prog", so it can be a program name with args.
10096 set dummy $ac_prog; ac_word=$2
10097 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10098 $as_echo_n "checking for $ac_word... " >&6; }
10099 if ${ac_cv_path_RMDIR+:} false; then :
10100   $as_echo_n "(cached) " >&6
10101 else
10102   case $RMDIR in
10103   [\\/]* | ?:[\\/]*)
10104   ac_cv_path_RMDIR="$RMDIR" # Let the user override the test with a path.
10105   ;;
10106   *)
10107   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10108 for as_dir in $PATH
10109 do
10110   IFS=$as_save_IFS
10111   test -z "$as_dir" && as_dir=.
10112     for ac_exec_ext in '' $ac_executable_extensions; do
10113   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10114     ac_cv_path_RMDIR="$as_dir/$ac_word$ac_exec_ext"
10115     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10116     break 2
10117   fi
10118 done
10119   done
10120 IFS=$as_save_IFS
10121 
10122   ;;
10123 esac
10124 fi
10125 RMDIR=$ac_cv_path_RMDIR
10126 if test -n "$RMDIR"; then
10127   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RMDIR" >&5
10128 $as_echo "$RMDIR" >&6; }
10129 else
10130   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10131 $as_echo "no" >&6; }
10132 fi
10133 
10134 
10135   test -n "$RMDIR" && break
10136 done
10137 
10138     else
10139       # If it succeeded, then it was overridden by the user. We will use it
10140       # for the tool.
10141 
10142       # First remove it from the list of overridden variables, so we can test
10143       # for unknown variables in the end.
10144       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10145 
10146       # Check if we try to supply an empty value
10147       if test "x$RMDIR" = x; then
10148         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool RMDIR= (no value)" >&5
10149 $as_echo "$as_me: Setting user supplied tool RMDIR= (no value)" >&6;}
10150         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for RMDIR" >&5
10151 $as_echo_n "checking for RMDIR... " >&6; }
10152         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
10153 $as_echo "disabled" >&6; }
10154       else
10155         # Check if the provided tool contains a complete path.
10156         tool_specified="$RMDIR"
10157         tool_basename="${tool_specified##*/}"
10158         if test "x$tool_basename" = "x$tool_specified"; then
10159           # A command without a complete path is provided, search $PATH.
10160           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool RMDIR=$tool_basename" >&5
10161 $as_echo "$as_me: Will search for user supplied tool RMDIR=$tool_basename" >&6;}
10162           # Extract the first word of "$tool_basename", so it can be a program name with args.
10163 set dummy $tool_basename; ac_word=$2
10164 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10165 $as_echo_n "checking for $ac_word... " >&6; }
10166 if ${ac_cv_path_RMDIR+:} false; then :
10167   $as_echo_n "(cached) " >&6
10168 else
10169   case $RMDIR in
10170   [\\/]* | ?:[\\/]*)
10171   ac_cv_path_RMDIR="$RMDIR" # Let the user override the test with a path.
10172   ;;
10173   *)
10174   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10175 for as_dir in $PATH
10176 do
10177   IFS=$as_save_IFS
10178   test -z "$as_dir" && as_dir=.
10179     for ac_exec_ext in '' $ac_executable_extensions; do
10180   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10181     ac_cv_path_RMDIR="$as_dir/$ac_word$ac_exec_ext"
10182     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10183     break 2
10184   fi
10185 done
10186   done
10187 IFS=$as_save_IFS
10188 
10189   ;;
10190 esac
10191 fi
10192 RMDIR=$ac_cv_path_RMDIR
10193 if test -n "$RMDIR"; then
10194   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RMDIR" >&5
10195 $as_echo "$RMDIR" >&6; }
10196 else
10197   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10198 $as_echo "no" >&6; }
10199 fi
10200 
10201 
10202           if test "x$RMDIR" = x; then
10203             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10204           fi
10205         else
10206           # Otherwise we believe it is a complete path. Use it as it is.
10207           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool RMDIR=$tool_specified" >&5
10208 $as_echo "$as_me: Will use user supplied tool RMDIR=$tool_specified" >&6;}
10209           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for RMDIR" >&5
10210 $as_echo_n "checking for RMDIR... " >&6; }
10211           if test ! -x "$tool_specified"; then
10212             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10213 $as_echo "not found" >&6; }
10214             as_fn_error $? "User supplied tool RMDIR=$tool_specified does not exist or is not executable" "$LINENO" 5
10215           fi
10216           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10217 $as_echo "$tool_specified" >&6; }
10218         fi
10219       fi
10220     fi
10221 
10222   fi
10223 
10224 
10225 
10226   if test "x$RMDIR" = x; then
10227     as_fn_error $? "Could not find required tool for RMDIR" "$LINENO" 5
10228   fi
10229 
10230 
10231 
10232 
10233 
10234   # Publish this variable in the help.
10235 
10236 
10237   if [ -z "${SH+x}" ]; then
10238     # The variable is not set by user, try to locate tool using the code snippet
10239     for ac_prog in sh
10240 do
10241   # Extract the first word of "$ac_prog", so it can be a program name with args.
10242 set dummy $ac_prog; ac_word=$2
10243 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10244 $as_echo_n "checking for $ac_word... " >&6; }
10245 if ${ac_cv_path_SH+:} false; then :
10246   $as_echo_n "(cached) " >&6
10247 else
10248   case $SH in
10249   [\\/]* | ?:[\\/]*)
10250   ac_cv_path_SH="$SH" # Let the user override the test with a path.
10251   ;;
10252   *)
10253   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10254 for as_dir in $PATH
10255 do
10256   IFS=$as_save_IFS
10257   test -z "$as_dir" && as_dir=.
10258     for ac_exec_ext in '' $ac_executable_extensions; do
10259   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10260     ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
10261     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10262     break 2
10263   fi
10264 done
10265   done
10266 IFS=$as_save_IFS
10267 
10268   ;;
10269 esac
10270 fi
10271 SH=$ac_cv_path_SH
10272 if test -n "$SH"; then
10273   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
10274 $as_echo "$SH" >&6; }
10275 else
10276   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10277 $as_echo "no" >&6; }
10278 fi
10279 
10280 
10281   test -n "$SH" && break
10282 done
10283 
10284   else
10285     # The variable is set, but is it from the command line or the environment?
10286 
10287     # Try to remove the string !SH! from our list.
10288     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SH!/}
10289     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10290       # If it failed, the variable was not from the command line. Ignore it,
10291       # but warn the user (except for BASH, which is always set by the calling BASH).
10292       if test "xSH" != xBASH; then
10293         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SH from the environment. Use command line variables instead." >&5
10294 $as_echo "$as_me: WARNING: Ignoring value of SH from the environment. Use command line variables instead." >&2;}
10295       fi
10296       # Try to locate tool using the code snippet
10297       for ac_prog in sh
10298 do
10299   # Extract the first word of "$ac_prog", so it can be a program name with args.
10300 set dummy $ac_prog; ac_word=$2
10301 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10302 $as_echo_n "checking for $ac_word... " >&6; }
10303 if ${ac_cv_path_SH+:} false; then :
10304   $as_echo_n "(cached) " >&6
10305 else
10306   case $SH in
10307   [\\/]* | ?:[\\/]*)
10308   ac_cv_path_SH="$SH" # Let the user override the test with a path.
10309   ;;
10310   *)
10311   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10312 for as_dir in $PATH
10313 do
10314   IFS=$as_save_IFS
10315   test -z "$as_dir" && as_dir=.
10316     for ac_exec_ext in '' $ac_executable_extensions; do
10317   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10318     ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
10319     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10320     break 2
10321   fi
10322 done
10323   done
10324 IFS=$as_save_IFS
10325 
10326   ;;
10327 esac
10328 fi
10329 SH=$ac_cv_path_SH
10330 if test -n "$SH"; then
10331   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
10332 $as_echo "$SH" >&6; }
10333 else
10334   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10335 $as_echo "no" >&6; }
10336 fi
10337 
10338 
10339   test -n "$SH" && break
10340 done
10341 
10342     else
10343       # If it succeeded, then it was overridden by the user. We will use it
10344       # for the tool.
10345 
10346       # First remove it from the list of overridden variables, so we can test
10347       # for unknown variables in the end.
10348       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10349 
10350       # Check if we try to supply an empty value
10351       if test "x$SH" = x; then
10352         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool SH= (no value)" >&5
10353 $as_echo "$as_me: Setting user supplied tool SH= (no value)" >&6;}
10354         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SH" >&5
10355 $as_echo_n "checking for SH... " >&6; }
10356         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
10357 $as_echo "disabled" >&6; }
10358       else
10359         # Check if the provided tool contains a complete path.
10360         tool_specified="$SH"
10361         tool_basename="${tool_specified##*/}"
10362         if test "x$tool_basename" = "x$tool_specified"; then
10363           # A command without a complete path is provided, search $PATH.
10364           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SH=$tool_basename" >&5
10365 $as_echo "$as_me: Will search for user supplied tool SH=$tool_basename" >&6;}
10366           # Extract the first word of "$tool_basename", so it can be a program name with args.
10367 set dummy $tool_basename; ac_word=$2
10368 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10369 $as_echo_n "checking for $ac_word... " >&6; }
10370 if ${ac_cv_path_SH+:} false; then :
10371   $as_echo_n "(cached) " >&6
10372 else
10373   case $SH in
10374   [\\/]* | ?:[\\/]*)
10375   ac_cv_path_SH="$SH" # Let the user override the test with a path.
10376   ;;
10377   *)
10378   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10379 for as_dir in $PATH
10380 do
10381   IFS=$as_save_IFS
10382   test -z "$as_dir" && as_dir=.
10383     for ac_exec_ext in '' $ac_executable_extensions; do
10384   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10385     ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
10386     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10387     break 2
10388   fi
10389 done
10390   done
10391 IFS=$as_save_IFS
10392 
10393   ;;
10394 esac
10395 fi
10396 SH=$ac_cv_path_SH
10397 if test -n "$SH"; then
10398   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
10399 $as_echo "$SH" >&6; }
10400 else
10401   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10402 $as_echo "no" >&6; }
10403 fi
10404 
10405 
10406           if test "x$SH" = x; then
10407             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10408           fi
10409         else
10410           # Otherwise we believe it is a complete path. Use it as it is.
10411           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SH=$tool_specified" >&5
10412 $as_echo "$as_me: Will use user supplied tool SH=$tool_specified" >&6;}
10413           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SH" >&5
10414 $as_echo_n "checking for SH... " >&6; }
10415           if test ! -x "$tool_specified"; then
10416             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10417 $as_echo "not found" >&6; }
10418             as_fn_error $? "User supplied tool SH=$tool_specified does not exist or is not executable" "$LINENO" 5
10419           fi
10420           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10421 $as_echo "$tool_specified" >&6; }
10422         fi
10423       fi
10424     fi
10425 
10426   fi
10427 
10428 
10429 
10430   if test "x$SH" = x; then
10431     as_fn_error $? "Could not find required tool for SH" "$LINENO" 5
10432   fi
10433 
10434 
10435 
10436 
10437 
10438   # Publish this variable in the help.
10439 
10440 
10441   if [ -z "${SORT+x}" ]; then
10442     # The variable is not set by user, try to locate tool using the code snippet
10443     for ac_prog in sort
10444 do
10445   # Extract the first word of "$ac_prog", so it can be a program name with args.
10446 set dummy $ac_prog; ac_word=$2
10447 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10448 $as_echo_n "checking for $ac_word... " >&6; }
10449 if ${ac_cv_path_SORT+:} false; then :
10450   $as_echo_n "(cached) " >&6
10451 else
10452   case $SORT in
10453   [\\/]* | ?:[\\/]*)
10454   ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
10455   ;;
10456   *)
10457   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10458 for as_dir in $PATH
10459 do
10460   IFS=$as_save_IFS
10461   test -z "$as_dir" && as_dir=.
10462     for ac_exec_ext in '' $ac_executable_extensions; do
10463   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10464     ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
10465     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10466     break 2
10467   fi
10468 done
10469   done
10470 IFS=$as_save_IFS
10471 
10472   ;;
10473 esac
10474 fi
10475 SORT=$ac_cv_path_SORT
10476 if test -n "$SORT"; then
10477   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
10478 $as_echo "$SORT" >&6; }
10479 else
10480   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10481 $as_echo "no" >&6; }
10482 fi
10483 
10484 
10485   test -n "$SORT" && break
10486 done
10487 
10488   else
10489     # The variable is set, but is it from the command line or the environment?
10490 
10491     # Try to remove the string !SORT! from our list.
10492     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SORT!/}
10493     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10494       # If it failed, the variable was not from the command line. Ignore it,
10495       # but warn the user (except for BASH, which is always set by the calling BASH).
10496       if test "xSORT" != xBASH; then
10497         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SORT from the environment. Use command line variables instead." >&5
10498 $as_echo "$as_me: WARNING: Ignoring value of SORT from the environment. Use command line variables instead." >&2;}
10499       fi
10500       # Try to locate tool using the code snippet
10501       for ac_prog in sort
10502 do
10503   # Extract the first word of "$ac_prog", so it can be a program name with args.
10504 set dummy $ac_prog; ac_word=$2
10505 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10506 $as_echo_n "checking for $ac_word... " >&6; }
10507 if ${ac_cv_path_SORT+:} false; then :
10508   $as_echo_n "(cached) " >&6
10509 else
10510   case $SORT in
10511   [\\/]* | ?:[\\/]*)
10512   ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
10513   ;;
10514   *)
10515   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10516 for as_dir in $PATH
10517 do
10518   IFS=$as_save_IFS
10519   test -z "$as_dir" && as_dir=.
10520     for ac_exec_ext in '' $ac_executable_extensions; do
10521   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10522     ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
10523     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10524     break 2
10525   fi
10526 done
10527   done
10528 IFS=$as_save_IFS
10529 
10530   ;;
10531 esac
10532 fi
10533 SORT=$ac_cv_path_SORT
10534 if test -n "$SORT"; then
10535   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
10536 $as_echo "$SORT" >&6; }
10537 else
10538   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10539 $as_echo "no" >&6; }
10540 fi
10541 
10542 
10543   test -n "$SORT" && break
10544 done
10545 
10546     else
10547       # If it succeeded, then it was overridden by the user. We will use it
10548       # for the tool.
10549 
10550       # First remove it from the list of overridden variables, so we can test
10551       # for unknown variables in the end.
10552       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10553 
10554       # Check if we try to supply an empty value
10555       if test "x$SORT" = x; then
10556         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool SORT= (no value)" >&5
10557 $as_echo "$as_me: Setting user supplied tool SORT= (no value)" >&6;}
10558         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SORT" >&5
10559 $as_echo_n "checking for SORT... " >&6; }
10560         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
10561 $as_echo "disabled" >&6; }
10562       else
10563         # Check if the provided tool contains a complete path.
10564         tool_specified="$SORT"
10565         tool_basename="${tool_specified##*/}"
10566         if test "x$tool_basename" = "x$tool_specified"; then
10567           # A command without a complete path is provided, search $PATH.
10568           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SORT=$tool_basename" >&5
10569 $as_echo "$as_me: Will search for user supplied tool SORT=$tool_basename" >&6;}
10570           # Extract the first word of "$tool_basename", so it can be a program name with args.
10571 set dummy $tool_basename; ac_word=$2
10572 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10573 $as_echo_n "checking for $ac_word... " >&6; }
10574 if ${ac_cv_path_SORT+:} false; then :
10575   $as_echo_n "(cached) " >&6
10576 else
10577   case $SORT in
10578   [\\/]* | ?:[\\/]*)
10579   ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
10580   ;;
10581   *)
10582   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10583 for as_dir in $PATH
10584 do
10585   IFS=$as_save_IFS
10586   test -z "$as_dir" && as_dir=.
10587     for ac_exec_ext in '' $ac_executable_extensions; do
10588   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10589     ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
10590     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10591     break 2
10592   fi
10593 done
10594   done
10595 IFS=$as_save_IFS
10596 
10597   ;;
10598 esac
10599 fi
10600 SORT=$ac_cv_path_SORT
10601 if test -n "$SORT"; then
10602   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
10603 $as_echo "$SORT" >&6; }
10604 else
10605   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10606 $as_echo "no" >&6; }
10607 fi
10608 
10609 
10610           if test "x$SORT" = x; then
10611             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10612           fi
10613         else
10614           # Otherwise we believe it is a complete path. Use it as it is.
10615           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SORT=$tool_specified" >&5
10616 $as_echo "$as_me: Will use user supplied tool SORT=$tool_specified" >&6;}
10617           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SORT" >&5
10618 $as_echo_n "checking for SORT... " >&6; }
10619           if test ! -x "$tool_specified"; then
10620             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10621 $as_echo "not found" >&6; }
10622             as_fn_error $? "User supplied tool SORT=$tool_specified does not exist or is not executable" "$LINENO" 5
10623           fi
10624           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10625 $as_echo "$tool_specified" >&6; }
10626         fi
10627       fi
10628     fi
10629 
10630   fi
10631 
10632 
10633 
10634   if test "x$SORT" = x; then
10635     as_fn_error $? "Could not find required tool for SORT" "$LINENO" 5
10636   fi
10637 
10638 
10639 
10640 
10641 
10642   # Publish this variable in the help.
10643 
10644 
10645   if [ -z "${TAIL+x}" ]; then
10646     # The variable is not set by user, try to locate tool using the code snippet
10647     for ac_prog in tail
10648 do
10649   # Extract the first word of "$ac_prog", so it can be a program name with args.
10650 set dummy $ac_prog; ac_word=$2
10651 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10652 $as_echo_n "checking for $ac_word... " >&6; }
10653 if ${ac_cv_path_TAIL+:} false; then :
10654   $as_echo_n "(cached) " >&6
10655 else
10656   case $TAIL in
10657   [\\/]* | ?:[\\/]*)
10658   ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
10659   ;;
10660   *)
10661   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10662 for as_dir in $PATH
10663 do
10664   IFS=$as_save_IFS
10665   test -z "$as_dir" && as_dir=.
10666     for ac_exec_ext in '' $ac_executable_extensions; do
10667   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10668     ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
10669     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10670     break 2
10671   fi
10672 done
10673   done
10674 IFS=$as_save_IFS
10675 
10676   ;;
10677 esac
10678 fi
10679 TAIL=$ac_cv_path_TAIL
10680 if test -n "$TAIL"; then
10681   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
10682 $as_echo "$TAIL" >&6; }
10683 else
10684   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10685 $as_echo "no" >&6; }
10686 fi
10687 
10688 
10689   test -n "$TAIL" && break
10690 done
10691 
10692   else
10693     # The variable is set, but is it from the command line or the environment?
10694 
10695     # Try to remove the string !TAIL! from our list.
10696     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TAIL!/}
10697     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10698       # If it failed, the variable was not from the command line. Ignore it,
10699       # but warn the user (except for BASH, which is always set by the calling BASH).
10700       if test "xTAIL" != xBASH; then
10701         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TAIL from the environment. Use command line variables instead." >&5
10702 $as_echo "$as_me: WARNING: Ignoring value of TAIL from the environment. Use command line variables instead." >&2;}
10703       fi
10704       # Try to locate tool using the code snippet
10705       for ac_prog in tail
10706 do
10707   # Extract the first word of "$ac_prog", so it can be a program name with args.
10708 set dummy $ac_prog; ac_word=$2
10709 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10710 $as_echo_n "checking for $ac_word... " >&6; }
10711 if ${ac_cv_path_TAIL+:} false; then :
10712   $as_echo_n "(cached) " >&6
10713 else
10714   case $TAIL in
10715   [\\/]* | ?:[\\/]*)
10716   ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
10717   ;;
10718   *)
10719   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10720 for as_dir in $PATH
10721 do
10722   IFS=$as_save_IFS
10723   test -z "$as_dir" && as_dir=.
10724     for ac_exec_ext in '' $ac_executable_extensions; do
10725   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10726     ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
10727     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10728     break 2
10729   fi
10730 done
10731   done
10732 IFS=$as_save_IFS
10733 
10734   ;;
10735 esac
10736 fi
10737 TAIL=$ac_cv_path_TAIL
10738 if test -n "$TAIL"; then
10739   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
10740 $as_echo "$TAIL" >&6; }
10741 else
10742   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10743 $as_echo "no" >&6; }
10744 fi
10745 
10746 
10747   test -n "$TAIL" && break
10748 done
10749 
10750     else
10751       # If it succeeded, then it was overridden by the user. We will use it
10752       # for the tool.
10753 
10754       # First remove it from the list of overridden variables, so we can test
10755       # for unknown variables in the end.
10756       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10757 
10758       # Check if we try to supply an empty value
10759       if test "x$TAIL" = x; then
10760         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool TAIL= (no value)" >&5
10761 $as_echo "$as_me: Setting user supplied tool TAIL= (no value)" >&6;}
10762         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAIL" >&5
10763 $as_echo_n "checking for TAIL... " >&6; }
10764         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
10765 $as_echo "disabled" >&6; }
10766       else
10767         # Check if the provided tool contains a complete path.
10768         tool_specified="$TAIL"
10769         tool_basename="${tool_specified##*/}"
10770         if test "x$tool_basename" = "x$tool_specified"; then
10771           # A command without a complete path is provided, search $PATH.
10772           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TAIL=$tool_basename" >&5
10773 $as_echo "$as_me: Will search for user supplied tool TAIL=$tool_basename" >&6;}
10774           # Extract the first word of "$tool_basename", so it can be a program name with args.
10775 set dummy $tool_basename; ac_word=$2
10776 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10777 $as_echo_n "checking for $ac_word... " >&6; }
10778 if ${ac_cv_path_TAIL+:} false; then :
10779   $as_echo_n "(cached) " >&6
10780 else
10781   case $TAIL in
10782   [\\/]* | ?:[\\/]*)
10783   ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
10784   ;;
10785   *)
10786   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10787 for as_dir in $PATH
10788 do
10789   IFS=$as_save_IFS
10790   test -z "$as_dir" && as_dir=.
10791     for ac_exec_ext in '' $ac_executable_extensions; do
10792   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10793     ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
10794     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10795     break 2
10796   fi
10797 done
10798   done
10799 IFS=$as_save_IFS
10800 
10801   ;;
10802 esac
10803 fi
10804 TAIL=$ac_cv_path_TAIL
10805 if test -n "$TAIL"; then
10806   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
10807 $as_echo "$TAIL" >&6; }
10808 else
10809   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10810 $as_echo "no" >&6; }
10811 fi
10812 
10813 
10814           if test "x$TAIL" = x; then
10815             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10816           fi
10817         else
10818           # Otherwise we believe it is a complete path. Use it as it is.
10819           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TAIL=$tool_specified" >&5
10820 $as_echo "$as_me: Will use user supplied tool TAIL=$tool_specified" >&6;}
10821           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAIL" >&5
10822 $as_echo_n "checking for TAIL... " >&6; }
10823           if test ! -x "$tool_specified"; then
10824             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10825 $as_echo "not found" >&6; }
10826             as_fn_error $? "User supplied tool TAIL=$tool_specified does not exist or is not executable" "$LINENO" 5
10827           fi
10828           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10829 $as_echo "$tool_specified" >&6; }
10830         fi
10831       fi
10832     fi
10833 
10834   fi
10835 
10836 
10837 
10838   if test "x$TAIL" = x; then
10839     as_fn_error $? "Could not find required tool for TAIL" "$LINENO" 5
10840   fi
10841 
10842 
10843 
10844 
10845 
10846   # Publish this variable in the help.
10847 
10848 
10849   if [ -z "${TAR+x}" ]; then
10850     # The variable is not set by user, try to locate tool using the code snippet
10851     for ac_prog in tar
10852 do
10853   # Extract the first word of "$ac_prog", so it can be a program name with args.
10854 set dummy $ac_prog; ac_word=$2
10855 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10856 $as_echo_n "checking for $ac_word... " >&6; }
10857 if ${ac_cv_path_TAR+:} false; then :
10858   $as_echo_n "(cached) " >&6
10859 else
10860   case $TAR in
10861   [\\/]* | ?:[\\/]*)
10862   ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
10863   ;;
10864   *)
10865   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10866 for as_dir in $PATH
10867 do
10868   IFS=$as_save_IFS
10869   test -z "$as_dir" && as_dir=.
10870     for ac_exec_ext in '' $ac_executable_extensions; do
10871   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10872     ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
10873     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10874     break 2
10875   fi
10876 done
10877   done
10878 IFS=$as_save_IFS
10879 
10880   ;;
10881 esac
10882 fi
10883 TAR=$ac_cv_path_TAR
10884 if test -n "$TAR"; then
10885   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
10886 $as_echo "$TAR" >&6; }
10887 else
10888   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10889 $as_echo "no" >&6; }
10890 fi
10891 
10892 
10893   test -n "$TAR" && break
10894 done
10895 
10896   else
10897     # The variable is set, but is it from the command line or the environment?
10898 
10899     # Try to remove the string !TAR! from our list.
10900     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TAR!/}
10901     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10902       # If it failed, the variable was not from the command line. Ignore it,
10903       # but warn the user (except for BASH, which is always set by the calling BASH).
10904       if test "xTAR" != xBASH; then
10905         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TAR from the environment. Use command line variables instead." >&5
10906 $as_echo "$as_me: WARNING: Ignoring value of TAR from the environment. Use command line variables instead." >&2;}
10907       fi
10908       # Try to locate tool using the code snippet
10909       for ac_prog in tar
10910 do
10911   # Extract the first word of "$ac_prog", so it can be a program name with args.
10912 set dummy $ac_prog; ac_word=$2
10913 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10914 $as_echo_n "checking for $ac_word... " >&6; }
10915 if ${ac_cv_path_TAR+:} false; then :
10916   $as_echo_n "(cached) " >&6
10917 else
10918   case $TAR in
10919   [\\/]* | ?:[\\/]*)
10920   ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
10921   ;;
10922   *)
10923   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10924 for as_dir in $PATH
10925 do
10926   IFS=$as_save_IFS
10927   test -z "$as_dir" && as_dir=.
10928     for ac_exec_ext in '' $ac_executable_extensions; do
10929   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10930     ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
10931     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10932     break 2
10933   fi
10934 done
10935   done
10936 IFS=$as_save_IFS
10937 
10938   ;;
10939 esac
10940 fi
10941 TAR=$ac_cv_path_TAR
10942 if test -n "$TAR"; then
10943   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
10944 $as_echo "$TAR" >&6; }
10945 else
10946   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10947 $as_echo "no" >&6; }
10948 fi
10949 
10950 
10951   test -n "$TAR" && break
10952 done
10953 
10954     else
10955       # If it succeeded, then it was overridden by the user. We will use it
10956       # for the tool.
10957 
10958       # First remove it from the list of overridden variables, so we can test
10959       # for unknown variables in the end.
10960       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10961 
10962       # Check if we try to supply an empty value
10963       if test "x$TAR" = x; then
10964         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool TAR= (no value)" >&5
10965 $as_echo "$as_me: Setting user supplied tool TAR= (no value)" >&6;}
10966         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAR" >&5
10967 $as_echo_n "checking for TAR... " >&6; }
10968         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
10969 $as_echo "disabled" >&6; }
10970       else
10971         # Check if the provided tool contains a complete path.
10972         tool_specified="$TAR"
10973         tool_basename="${tool_specified##*/}"
10974         if test "x$tool_basename" = "x$tool_specified"; then
10975           # A command without a complete path is provided, search $PATH.
10976           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TAR=$tool_basename" >&5
10977 $as_echo "$as_me: Will search for user supplied tool TAR=$tool_basename" >&6;}
10978           # Extract the first word of "$tool_basename", so it can be a program name with args.
10979 set dummy $tool_basename; ac_word=$2
10980 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10981 $as_echo_n "checking for $ac_word... " >&6; }
10982 if ${ac_cv_path_TAR+:} false; then :
10983   $as_echo_n "(cached) " >&6
10984 else
10985   case $TAR in
10986   [\\/]* | ?:[\\/]*)
10987   ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
10988   ;;
10989   *)
10990   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10991 for as_dir in $PATH
10992 do
10993   IFS=$as_save_IFS
10994   test -z "$as_dir" && as_dir=.
10995     for ac_exec_ext in '' $ac_executable_extensions; do
10996   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10997     ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
10998     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10999     break 2
11000   fi
11001 done
11002   done
11003 IFS=$as_save_IFS
11004 
11005   ;;
11006 esac
11007 fi
11008 TAR=$ac_cv_path_TAR
11009 if test -n "$TAR"; then
11010   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
11011 $as_echo "$TAR" >&6; }
11012 else
11013   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11014 $as_echo "no" >&6; }
11015 fi
11016 
11017 
11018           if test "x$TAR" = x; then
11019             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11020           fi
11021         else
11022           # Otherwise we believe it is a complete path. Use it as it is.
11023           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TAR=$tool_specified" >&5
11024 $as_echo "$as_me: Will use user supplied tool TAR=$tool_specified" >&6;}
11025           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAR" >&5
11026 $as_echo_n "checking for TAR... " >&6; }
11027           if test ! -x "$tool_specified"; then
11028             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11029 $as_echo "not found" >&6; }
11030             as_fn_error $? "User supplied tool TAR=$tool_specified does not exist or is not executable" "$LINENO" 5
11031           fi
11032           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11033 $as_echo "$tool_specified" >&6; }
11034         fi
11035       fi
11036     fi
11037 
11038   fi
11039 
11040 
11041 
11042   if test "x$TAR" = x; then
11043     as_fn_error $? "Could not find required tool for TAR" "$LINENO" 5
11044   fi
11045 
11046 
11047 
11048 
11049 
11050   # Publish this variable in the help.
11051 
11052 
11053   if [ -z "${TEE+x}" ]; then
11054     # The variable is not set by user, try to locate tool using the code snippet
11055     for ac_prog in tee
11056 do
11057   # Extract the first word of "$ac_prog", so it can be a program name with args.
11058 set dummy $ac_prog; ac_word=$2
11059 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11060 $as_echo_n "checking for $ac_word... " >&6; }
11061 if ${ac_cv_path_TEE+:} false; then :
11062   $as_echo_n "(cached) " >&6
11063 else
11064   case $TEE in
11065   [\\/]* | ?:[\\/]*)
11066   ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
11067   ;;
11068   *)
11069   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11070 for as_dir in $PATH
11071 do
11072   IFS=$as_save_IFS
11073   test -z "$as_dir" && as_dir=.
11074     for ac_exec_ext in '' $ac_executable_extensions; do
11075   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11076     ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
11077     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11078     break 2
11079   fi
11080 done
11081   done
11082 IFS=$as_save_IFS
11083 
11084   ;;
11085 esac
11086 fi
11087 TEE=$ac_cv_path_TEE
11088 if test -n "$TEE"; then
11089   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
11090 $as_echo "$TEE" >&6; }
11091 else
11092   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11093 $as_echo "no" >&6; }
11094 fi
11095 
11096 
11097   test -n "$TEE" && break
11098 done
11099 
11100   else
11101     # The variable is set, but is it from the command line or the environment?
11102 
11103     # Try to remove the string !TEE! from our list.
11104     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TEE!/}
11105     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11106       # If it failed, the variable was not from the command line. Ignore it,
11107       # but warn the user (except for BASH, which is always set by the calling BASH).
11108       if test "xTEE" != xBASH; then
11109         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TEE from the environment. Use command line variables instead." >&5
11110 $as_echo "$as_me: WARNING: Ignoring value of TEE from the environment. Use command line variables instead." >&2;}
11111       fi
11112       # Try to locate tool using the code snippet
11113       for ac_prog in tee
11114 do
11115   # Extract the first word of "$ac_prog", so it can be a program name with args.
11116 set dummy $ac_prog; ac_word=$2
11117 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11118 $as_echo_n "checking for $ac_word... " >&6; }
11119 if ${ac_cv_path_TEE+:} false; then :
11120   $as_echo_n "(cached) " >&6
11121 else
11122   case $TEE in
11123   [\\/]* | ?:[\\/]*)
11124   ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
11125   ;;
11126   *)
11127   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11128 for as_dir in $PATH
11129 do
11130   IFS=$as_save_IFS
11131   test -z "$as_dir" && as_dir=.
11132     for ac_exec_ext in '' $ac_executable_extensions; do
11133   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11134     ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
11135     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11136     break 2
11137   fi
11138 done
11139   done
11140 IFS=$as_save_IFS
11141 
11142   ;;
11143 esac
11144 fi
11145 TEE=$ac_cv_path_TEE
11146 if test -n "$TEE"; then
11147   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
11148 $as_echo "$TEE" >&6; }
11149 else
11150   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11151 $as_echo "no" >&6; }
11152 fi
11153 
11154 
11155   test -n "$TEE" && break
11156 done
11157 
11158     else
11159       # If it succeeded, then it was overridden by the user. We will use it
11160       # for the tool.
11161 
11162       # First remove it from the list of overridden variables, so we can test
11163       # for unknown variables in the end.
11164       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11165 
11166       # Check if we try to supply an empty value
11167       if test "x$TEE" = x; then
11168         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool TEE= (no value)" >&5
11169 $as_echo "$as_me: Setting user supplied tool TEE= (no value)" >&6;}
11170         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TEE" >&5
11171 $as_echo_n "checking for TEE... " >&6; }
11172         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
11173 $as_echo "disabled" >&6; }
11174       else
11175         # Check if the provided tool contains a complete path.
11176         tool_specified="$TEE"
11177         tool_basename="${tool_specified##*/}"
11178         if test "x$tool_basename" = "x$tool_specified"; then
11179           # A command without a complete path is provided, search $PATH.
11180           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TEE=$tool_basename" >&5
11181 $as_echo "$as_me: Will search for user supplied tool TEE=$tool_basename" >&6;}
11182           # Extract the first word of "$tool_basename", so it can be a program name with args.
11183 set dummy $tool_basename; ac_word=$2
11184 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11185 $as_echo_n "checking for $ac_word... " >&6; }
11186 if ${ac_cv_path_TEE+:} false; then :
11187   $as_echo_n "(cached) " >&6
11188 else
11189   case $TEE in
11190   [\\/]* | ?:[\\/]*)
11191   ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
11192   ;;
11193   *)
11194   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11195 for as_dir in $PATH
11196 do
11197   IFS=$as_save_IFS
11198   test -z "$as_dir" && as_dir=.
11199     for ac_exec_ext in '' $ac_executable_extensions; do
11200   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11201     ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
11202     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11203     break 2
11204   fi
11205 done
11206   done
11207 IFS=$as_save_IFS
11208 
11209   ;;
11210 esac
11211 fi
11212 TEE=$ac_cv_path_TEE
11213 if test -n "$TEE"; then
11214   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
11215 $as_echo "$TEE" >&6; }
11216 else
11217   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11218 $as_echo "no" >&6; }
11219 fi
11220 
11221 
11222           if test "x$TEE" = x; then
11223             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11224           fi
11225         else
11226           # Otherwise we believe it is a complete path. Use it as it is.
11227           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TEE=$tool_specified" >&5
11228 $as_echo "$as_me: Will use user supplied tool TEE=$tool_specified" >&6;}
11229           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TEE" >&5
11230 $as_echo_n "checking for TEE... " >&6; }
11231           if test ! -x "$tool_specified"; then
11232             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11233 $as_echo "not found" >&6; }
11234             as_fn_error $? "User supplied tool TEE=$tool_specified does not exist or is not executable" "$LINENO" 5
11235           fi
11236           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11237 $as_echo "$tool_specified" >&6; }
11238         fi
11239       fi
11240     fi
11241 
11242   fi
11243 
11244 
11245 
11246   if test "x$TEE" = x; then
11247     as_fn_error $? "Could not find required tool for TEE" "$LINENO" 5
11248   fi
11249 
11250 
11251 
11252 
11253 
11254   # Publish this variable in the help.
11255 
11256 
11257   if [ -z "${TOUCH+x}" ]; then
11258     # The variable is not set by user, try to locate tool using the code snippet
11259     for ac_prog in touch
11260 do
11261   # Extract the first word of "$ac_prog", so it can be a program name with args.
11262 set dummy $ac_prog; ac_word=$2
11263 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11264 $as_echo_n "checking for $ac_word... " >&6; }
11265 if ${ac_cv_path_TOUCH+:} false; then :
11266   $as_echo_n "(cached) " >&6
11267 else
11268   case $TOUCH in
11269   [\\/]* | ?:[\\/]*)
11270   ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
11271   ;;
11272   *)
11273   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11274 for as_dir in $PATH
11275 do
11276   IFS=$as_save_IFS
11277   test -z "$as_dir" && as_dir=.
11278     for ac_exec_ext in '' $ac_executable_extensions; do
11279   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11280     ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
11281     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11282     break 2
11283   fi
11284 done
11285   done
11286 IFS=$as_save_IFS
11287 
11288   ;;
11289 esac
11290 fi
11291 TOUCH=$ac_cv_path_TOUCH
11292 if test -n "$TOUCH"; then
11293   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
11294 $as_echo "$TOUCH" >&6; }
11295 else
11296   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11297 $as_echo "no" >&6; }
11298 fi
11299 
11300 
11301   test -n "$TOUCH" && break
11302 done
11303 
11304   else
11305     # The variable is set, but is it from the command line or the environment?
11306 
11307     # Try to remove the string !TOUCH! from our list.
11308     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TOUCH!/}
11309     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11310       # If it failed, the variable was not from the command line. Ignore it,
11311       # but warn the user (except for BASH, which is always set by the calling BASH).
11312       if test "xTOUCH" != xBASH; then
11313         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TOUCH from the environment. Use command line variables instead." >&5
11314 $as_echo "$as_me: WARNING: Ignoring value of TOUCH from the environment. Use command line variables instead." >&2;}
11315       fi
11316       # Try to locate tool using the code snippet
11317       for ac_prog in touch
11318 do
11319   # Extract the first word of "$ac_prog", so it can be a program name with args.
11320 set dummy $ac_prog; ac_word=$2
11321 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11322 $as_echo_n "checking for $ac_word... " >&6; }
11323 if ${ac_cv_path_TOUCH+:} false; then :
11324   $as_echo_n "(cached) " >&6
11325 else
11326   case $TOUCH in
11327   [\\/]* | ?:[\\/]*)
11328   ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
11329   ;;
11330   *)
11331   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11332 for as_dir in $PATH
11333 do
11334   IFS=$as_save_IFS
11335   test -z "$as_dir" && as_dir=.
11336     for ac_exec_ext in '' $ac_executable_extensions; do
11337   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11338     ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
11339     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11340     break 2
11341   fi
11342 done
11343   done
11344 IFS=$as_save_IFS
11345 
11346   ;;
11347 esac
11348 fi
11349 TOUCH=$ac_cv_path_TOUCH
11350 if test -n "$TOUCH"; then
11351   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
11352 $as_echo "$TOUCH" >&6; }
11353 else
11354   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11355 $as_echo "no" >&6; }
11356 fi
11357 
11358 
11359   test -n "$TOUCH" && break
11360 done
11361 
11362     else
11363       # If it succeeded, then it was overridden by the user. We will use it
11364       # for the tool.
11365 
11366       # First remove it from the list of overridden variables, so we can test
11367       # for unknown variables in the end.
11368       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11369 
11370       # Check if we try to supply an empty value
11371       if test "x$TOUCH" = x; then
11372         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool TOUCH= (no value)" >&5
11373 $as_echo "$as_me: Setting user supplied tool TOUCH= (no value)" >&6;}
11374         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TOUCH" >&5
11375 $as_echo_n "checking for TOUCH... " >&6; }
11376         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
11377 $as_echo "disabled" >&6; }
11378       else
11379         # Check if the provided tool contains a complete path.
11380         tool_specified="$TOUCH"
11381         tool_basename="${tool_specified##*/}"
11382         if test "x$tool_basename" = "x$tool_specified"; then
11383           # A command without a complete path is provided, search $PATH.
11384           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TOUCH=$tool_basename" >&5
11385 $as_echo "$as_me: Will search for user supplied tool TOUCH=$tool_basename" >&6;}
11386           # Extract the first word of "$tool_basename", so it can be a program name with args.
11387 set dummy $tool_basename; ac_word=$2
11388 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11389 $as_echo_n "checking for $ac_word... " >&6; }
11390 if ${ac_cv_path_TOUCH+:} false; then :
11391   $as_echo_n "(cached) " >&6
11392 else
11393   case $TOUCH in
11394   [\\/]* | ?:[\\/]*)
11395   ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
11396   ;;
11397   *)
11398   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11399 for as_dir in $PATH
11400 do
11401   IFS=$as_save_IFS
11402   test -z "$as_dir" && as_dir=.
11403     for ac_exec_ext in '' $ac_executable_extensions; do
11404   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11405     ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
11406     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11407     break 2
11408   fi
11409 done
11410   done
11411 IFS=$as_save_IFS
11412 
11413   ;;
11414 esac
11415 fi
11416 TOUCH=$ac_cv_path_TOUCH
11417 if test -n "$TOUCH"; then
11418   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
11419 $as_echo "$TOUCH" >&6; }
11420 else
11421   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11422 $as_echo "no" >&6; }
11423 fi
11424 
11425 
11426           if test "x$TOUCH" = x; then
11427             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11428           fi
11429         else
11430           # Otherwise we believe it is a complete path. Use it as it is.
11431           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TOUCH=$tool_specified" >&5
11432 $as_echo "$as_me: Will use user supplied tool TOUCH=$tool_specified" >&6;}
11433           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TOUCH" >&5
11434 $as_echo_n "checking for TOUCH... " >&6; }
11435           if test ! -x "$tool_specified"; then
11436             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11437 $as_echo "not found" >&6; }
11438             as_fn_error $? "User supplied tool TOUCH=$tool_specified does not exist or is not executable" "$LINENO" 5
11439           fi
11440           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11441 $as_echo "$tool_specified" >&6; }
11442         fi
11443       fi
11444     fi
11445 
11446   fi
11447 
11448 
11449 
11450   if test "x$TOUCH" = x; then
11451     as_fn_error $? "Could not find required tool for TOUCH" "$LINENO" 5
11452   fi
11453 
11454 
11455 
11456 
11457 
11458   # Publish this variable in the help.
11459 
11460 
11461   if [ -z "${TR+x}" ]; then
11462     # The variable is not set by user, try to locate tool using the code snippet
11463     for ac_prog in tr
11464 do
11465   # Extract the first word of "$ac_prog", so it can be a program name with args.
11466 set dummy $ac_prog; ac_word=$2
11467 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11468 $as_echo_n "checking for $ac_word... " >&6; }
11469 if ${ac_cv_path_TR+:} false; then :
11470   $as_echo_n "(cached) " >&6
11471 else
11472   case $TR in
11473   [\\/]* | ?:[\\/]*)
11474   ac_cv_path_TR="$TR" # Let the user override the test with a path.
11475   ;;
11476   *)
11477   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11478 for as_dir in $PATH
11479 do
11480   IFS=$as_save_IFS
11481   test -z "$as_dir" && as_dir=.
11482     for ac_exec_ext in '' $ac_executable_extensions; do
11483   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11484     ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
11485     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11486     break 2
11487   fi
11488 done
11489   done
11490 IFS=$as_save_IFS
11491 
11492   ;;
11493 esac
11494 fi
11495 TR=$ac_cv_path_TR
11496 if test -n "$TR"; then
11497   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
11498 $as_echo "$TR" >&6; }
11499 else
11500   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11501 $as_echo "no" >&6; }
11502 fi
11503 
11504 
11505   test -n "$TR" && break
11506 done
11507 
11508   else
11509     # The variable is set, but is it from the command line or the environment?
11510 
11511     # Try to remove the string !TR! from our list.
11512     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TR!/}
11513     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11514       # If it failed, the variable was not from the command line. Ignore it,
11515       # but warn the user (except for BASH, which is always set by the calling BASH).
11516       if test "xTR" != xBASH; then
11517         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TR from the environment. Use command line variables instead." >&5
11518 $as_echo "$as_me: WARNING: Ignoring value of TR from the environment. Use command line variables instead." >&2;}
11519       fi
11520       # Try to locate tool using the code snippet
11521       for ac_prog in tr
11522 do
11523   # Extract the first word of "$ac_prog", so it can be a program name with args.
11524 set dummy $ac_prog; ac_word=$2
11525 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11526 $as_echo_n "checking for $ac_word... " >&6; }
11527 if ${ac_cv_path_TR+:} false; then :
11528   $as_echo_n "(cached) " >&6
11529 else
11530   case $TR in
11531   [\\/]* | ?:[\\/]*)
11532   ac_cv_path_TR="$TR" # Let the user override the test with a path.
11533   ;;
11534   *)
11535   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11536 for as_dir in $PATH
11537 do
11538   IFS=$as_save_IFS
11539   test -z "$as_dir" && as_dir=.
11540     for ac_exec_ext in '' $ac_executable_extensions; do
11541   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11542     ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
11543     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11544     break 2
11545   fi
11546 done
11547   done
11548 IFS=$as_save_IFS
11549 
11550   ;;
11551 esac
11552 fi
11553 TR=$ac_cv_path_TR
11554 if test -n "$TR"; then
11555   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
11556 $as_echo "$TR" >&6; }
11557 else
11558   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11559 $as_echo "no" >&6; }
11560 fi
11561 
11562 
11563   test -n "$TR" && break
11564 done
11565 
11566     else
11567       # If it succeeded, then it was overridden by the user. We will use it
11568       # for the tool.
11569 
11570       # First remove it from the list of overridden variables, so we can test
11571       # for unknown variables in the end.
11572       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11573 
11574       # Check if we try to supply an empty value
11575       if test "x$TR" = x; then
11576         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool TR= (no value)" >&5
11577 $as_echo "$as_me: Setting user supplied tool TR= (no value)" >&6;}
11578         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TR" >&5
11579 $as_echo_n "checking for TR... " >&6; }
11580         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
11581 $as_echo "disabled" >&6; }
11582       else
11583         # Check if the provided tool contains a complete path.
11584         tool_specified="$TR"
11585         tool_basename="${tool_specified##*/}"
11586         if test "x$tool_basename" = "x$tool_specified"; then
11587           # A command without a complete path is provided, search $PATH.
11588           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TR=$tool_basename" >&5
11589 $as_echo "$as_me: Will search for user supplied tool TR=$tool_basename" >&6;}
11590           # Extract the first word of "$tool_basename", so it can be a program name with args.
11591 set dummy $tool_basename; ac_word=$2
11592 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11593 $as_echo_n "checking for $ac_word... " >&6; }
11594 if ${ac_cv_path_TR+:} false; then :
11595   $as_echo_n "(cached) " >&6
11596 else
11597   case $TR in
11598   [\\/]* | ?:[\\/]*)
11599   ac_cv_path_TR="$TR" # Let the user override the test with a path.
11600   ;;
11601   *)
11602   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11603 for as_dir in $PATH
11604 do
11605   IFS=$as_save_IFS
11606   test -z "$as_dir" && as_dir=.
11607     for ac_exec_ext in '' $ac_executable_extensions; do
11608   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11609     ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
11610     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11611     break 2
11612   fi
11613 done
11614   done
11615 IFS=$as_save_IFS
11616 
11617   ;;
11618 esac
11619 fi
11620 TR=$ac_cv_path_TR
11621 if test -n "$TR"; then
11622   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
11623 $as_echo "$TR" >&6; }
11624 else
11625   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11626 $as_echo "no" >&6; }
11627 fi
11628 
11629 
11630           if test "x$TR" = x; then
11631             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11632           fi
11633         else
11634           # Otherwise we believe it is a complete path. Use it as it is.
11635           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TR=$tool_specified" >&5
11636 $as_echo "$as_me: Will use user supplied tool TR=$tool_specified" >&6;}
11637           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TR" >&5
11638 $as_echo_n "checking for TR... " >&6; }
11639           if test ! -x "$tool_specified"; then
11640             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11641 $as_echo "not found" >&6; }
11642             as_fn_error $? "User supplied tool TR=$tool_specified does not exist or is not executable" "$LINENO" 5
11643           fi
11644           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11645 $as_echo "$tool_specified" >&6; }
11646         fi
11647       fi
11648     fi
11649 
11650   fi
11651 
11652 
11653 
11654   if test "x$TR" = x; then
11655     as_fn_error $? "Could not find required tool for TR" "$LINENO" 5
11656   fi
11657 
11658 
11659 
11660 
11661 
11662   # Publish this variable in the help.
11663 
11664 
11665   if [ -z "${UNAME+x}" ]; then
11666     # The variable is not set by user, try to locate tool using the code snippet
11667     for ac_prog in uname
11668 do
11669   # Extract the first word of "$ac_prog", so it can be a program name with args.
11670 set dummy $ac_prog; ac_word=$2
11671 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11672 $as_echo_n "checking for $ac_word... " >&6; }
11673 if ${ac_cv_path_UNAME+:} false; then :
11674   $as_echo_n "(cached) " >&6
11675 else
11676   case $UNAME in
11677   [\\/]* | ?:[\\/]*)
11678   ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
11679   ;;
11680   *)
11681   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11682 for as_dir in $PATH
11683 do
11684   IFS=$as_save_IFS
11685   test -z "$as_dir" && as_dir=.
11686     for ac_exec_ext in '' $ac_executable_extensions; do
11687   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11688     ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
11689     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11690     break 2
11691   fi
11692 done
11693   done
11694 IFS=$as_save_IFS
11695 
11696   ;;
11697 esac
11698 fi
11699 UNAME=$ac_cv_path_UNAME
11700 if test -n "$UNAME"; then
11701   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
11702 $as_echo "$UNAME" >&6; }
11703 else
11704   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11705 $as_echo "no" >&6; }
11706 fi
11707 
11708 
11709   test -n "$UNAME" && break
11710 done
11711 
11712   else
11713     # The variable is set, but is it from the command line or the environment?
11714 
11715     # Try to remove the string !UNAME! from our list.
11716     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNAME!/}
11717     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11718       # If it failed, the variable was not from the command line. Ignore it,
11719       # but warn the user (except for BASH, which is always set by the calling BASH).
11720       if test "xUNAME" != xBASH; then
11721         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNAME from the environment. Use command line variables instead." >&5
11722 $as_echo "$as_me: WARNING: Ignoring value of UNAME from the environment. Use command line variables instead." >&2;}
11723       fi
11724       # Try to locate tool using the code snippet
11725       for ac_prog in uname
11726 do
11727   # Extract the first word of "$ac_prog", so it can be a program name with args.
11728 set dummy $ac_prog; ac_word=$2
11729 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11730 $as_echo_n "checking for $ac_word... " >&6; }
11731 if ${ac_cv_path_UNAME+:} false; then :
11732   $as_echo_n "(cached) " >&6
11733 else
11734   case $UNAME in
11735   [\\/]* | ?:[\\/]*)
11736   ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
11737   ;;
11738   *)
11739   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11740 for as_dir in $PATH
11741 do
11742   IFS=$as_save_IFS
11743   test -z "$as_dir" && as_dir=.
11744     for ac_exec_ext in '' $ac_executable_extensions; do
11745   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11746     ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
11747     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11748     break 2
11749   fi
11750 done
11751   done
11752 IFS=$as_save_IFS
11753 
11754   ;;
11755 esac
11756 fi
11757 UNAME=$ac_cv_path_UNAME
11758 if test -n "$UNAME"; then
11759   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
11760 $as_echo "$UNAME" >&6; }
11761 else
11762   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11763 $as_echo "no" >&6; }
11764 fi
11765 
11766 
11767   test -n "$UNAME" && break
11768 done
11769 
11770     else
11771       # If it succeeded, then it was overridden by the user. We will use it
11772       # for the tool.
11773 
11774       # First remove it from the list of overridden variables, so we can test
11775       # for unknown variables in the end.
11776       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11777 
11778       # Check if we try to supply an empty value
11779       if test "x$UNAME" = x; then
11780         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool UNAME= (no value)" >&5
11781 $as_echo "$as_me: Setting user supplied tool UNAME= (no value)" >&6;}
11782         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNAME" >&5
11783 $as_echo_n "checking for UNAME... " >&6; }
11784         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
11785 $as_echo "disabled" >&6; }
11786       else
11787         # Check if the provided tool contains a complete path.
11788         tool_specified="$UNAME"
11789         tool_basename="${tool_specified##*/}"
11790         if test "x$tool_basename" = "x$tool_specified"; then
11791           # A command without a complete path is provided, search $PATH.
11792           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNAME=$tool_basename" >&5
11793 $as_echo "$as_me: Will search for user supplied tool UNAME=$tool_basename" >&6;}
11794           # Extract the first word of "$tool_basename", so it can be a program name with args.
11795 set dummy $tool_basename; ac_word=$2
11796 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11797 $as_echo_n "checking for $ac_word... " >&6; }
11798 if ${ac_cv_path_UNAME+:} false; then :
11799   $as_echo_n "(cached) " >&6
11800 else
11801   case $UNAME in
11802   [\\/]* | ?:[\\/]*)
11803   ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
11804   ;;
11805   *)
11806   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11807 for as_dir in $PATH
11808 do
11809   IFS=$as_save_IFS
11810   test -z "$as_dir" && as_dir=.
11811     for ac_exec_ext in '' $ac_executable_extensions; do
11812   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11813     ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
11814     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11815     break 2
11816   fi
11817 done
11818   done
11819 IFS=$as_save_IFS
11820 
11821   ;;
11822 esac
11823 fi
11824 UNAME=$ac_cv_path_UNAME
11825 if test -n "$UNAME"; then
11826   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
11827 $as_echo "$UNAME" >&6; }
11828 else
11829   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11830 $as_echo "no" >&6; }
11831 fi
11832 
11833 
11834           if test "x$UNAME" = x; then
11835             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11836           fi
11837         else
11838           # Otherwise we believe it is a complete path. Use it as it is.
11839           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNAME=$tool_specified" >&5
11840 $as_echo "$as_me: Will use user supplied tool UNAME=$tool_specified" >&6;}
11841           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNAME" >&5
11842 $as_echo_n "checking for UNAME... " >&6; }
11843           if test ! -x "$tool_specified"; then
11844             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11845 $as_echo "not found" >&6; }
11846             as_fn_error $? "User supplied tool UNAME=$tool_specified does not exist or is not executable" "$LINENO" 5
11847           fi
11848           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11849 $as_echo "$tool_specified" >&6; }
11850         fi
11851       fi
11852     fi
11853 
11854   fi
11855 
11856 
11857 
11858   if test "x$UNAME" = x; then
11859     as_fn_error $? "Could not find required tool for UNAME" "$LINENO" 5
11860   fi
11861 
11862 
11863 
11864 
11865 
11866   # Publish this variable in the help.
11867 
11868 
11869   if [ -z "${UNIQ+x}" ]; then
11870     # The variable is not set by user, try to locate tool using the code snippet
11871     for ac_prog in uniq
11872 do
11873   # Extract the first word of "$ac_prog", so it can be a program name with args.
11874 set dummy $ac_prog; ac_word=$2
11875 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11876 $as_echo_n "checking for $ac_word... " >&6; }
11877 if ${ac_cv_path_UNIQ+:} false; then :
11878   $as_echo_n "(cached) " >&6
11879 else
11880   case $UNIQ in
11881   [\\/]* | ?:[\\/]*)
11882   ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
11883   ;;
11884   *)
11885   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11886 for as_dir in $PATH
11887 do
11888   IFS=$as_save_IFS
11889   test -z "$as_dir" && as_dir=.
11890     for ac_exec_ext in '' $ac_executable_extensions; do
11891   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11892     ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
11893     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11894     break 2
11895   fi
11896 done
11897   done
11898 IFS=$as_save_IFS
11899 
11900   ;;
11901 esac
11902 fi
11903 UNIQ=$ac_cv_path_UNIQ
11904 if test -n "$UNIQ"; then
11905   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
11906 $as_echo "$UNIQ" >&6; }
11907 else
11908   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11909 $as_echo "no" >&6; }
11910 fi
11911 
11912 
11913   test -n "$UNIQ" && break
11914 done
11915 
11916   else
11917     # The variable is set, but is it from the command line or the environment?
11918 
11919     # Try to remove the string !UNIQ! from our list.
11920     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNIQ!/}
11921     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11922       # If it failed, the variable was not from the command line. Ignore it,
11923       # but warn the user (except for BASH, which is always set by the calling BASH).
11924       if test "xUNIQ" != xBASH; then
11925         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNIQ from the environment. Use command line variables instead." >&5
11926 $as_echo "$as_me: WARNING: Ignoring value of UNIQ from the environment. Use command line variables instead." >&2;}
11927       fi
11928       # Try to locate tool using the code snippet
11929       for ac_prog in uniq
11930 do
11931   # Extract the first word of "$ac_prog", so it can be a program name with args.
11932 set dummy $ac_prog; ac_word=$2
11933 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11934 $as_echo_n "checking for $ac_word... " >&6; }
11935 if ${ac_cv_path_UNIQ+:} false; then :
11936   $as_echo_n "(cached) " >&6
11937 else
11938   case $UNIQ in
11939   [\\/]* | ?:[\\/]*)
11940   ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
11941   ;;
11942   *)
11943   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11944 for as_dir in $PATH
11945 do
11946   IFS=$as_save_IFS
11947   test -z "$as_dir" && as_dir=.
11948     for ac_exec_ext in '' $ac_executable_extensions; do
11949   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11950     ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
11951     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11952     break 2
11953   fi
11954 done
11955   done
11956 IFS=$as_save_IFS
11957 
11958   ;;
11959 esac
11960 fi
11961 UNIQ=$ac_cv_path_UNIQ
11962 if test -n "$UNIQ"; then
11963   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
11964 $as_echo "$UNIQ" >&6; }
11965 else
11966   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11967 $as_echo "no" >&6; }
11968 fi
11969 
11970 
11971   test -n "$UNIQ" && break
11972 done
11973 
11974     else
11975       # If it succeeded, then it was overridden by the user. We will use it
11976       # for the tool.
11977 
11978       # First remove it from the list of overridden variables, so we can test
11979       # for unknown variables in the end.
11980       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11981 
11982       # Check if we try to supply an empty value
11983       if test "x$UNIQ" = x; then
11984         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool UNIQ= (no value)" >&5
11985 $as_echo "$as_me: Setting user supplied tool UNIQ= (no value)" >&6;}
11986         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNIQ" >&5
11987 $as_echo_n "checking for UNIQ... " >&6; }
11988         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
11989 $as_echo "disabled" >&6; }
11990       else
11991         # Check if the provided tool contains a complete path.
11992         tool_specified="$UNIQ"
11993         tool_basename="${tool_specified##*/}"
11994         if test "x$tool_basename" = "x$tool_specified"; then
11995           # A command without a complete path is provided, search $PATH.
11996           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNIQ=$tool_basename" >&5
11997 $as_echo "$as_me: Will search for user supplied tool UNIQ=$tool_basename" >&6;}
11998           # Extract the first word of "$tool_basename", so it can be a program name with args.
11999 set dummy $tool_basename; ac_word=$2
12000 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12001 $as_echo_n "checking for $ac_word... " >&6; }
12002 if ${ac_cv_path_UNIQ+:} false; then :
12003   $as_echo_n "(cached) " >&6
12004 else
12005   case $UNIQ in
12006   [\\/]* | ?:[\\/]*)
12007   ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
12008   ;;
12009   *)
12010   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12011 for as_dir in $PATH
12012 do
12013   IFS=$as_save_IFS
12014   test -z "$as_dir" && as_dir=.
12015     for ac_exec_ext in '' $ac_executable_extensions; do
12016   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12017     ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
12018     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12019     break 2
12020   fi
12021 done
12022   done
12023 IFS=$as_save_IFS
12024 
12025   ;;
12026 esac
12027 fi
12028 UNIQ=$ac_cv_path_UNIQ
12029 if test -n "$UNIQ"; then
12030   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
12031 $as_echo "$UNIQ" >&6; }
12032 else
12033   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12034 $as_echo "no" >&6; }
12035 fi
12036 
12037 
12038           if test "x$UNIQ" = x; then
12039             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12040           fi
12041         else
12042           # Otherwise we believe it is a complete path. Use it as it is.
12043           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNIQ=$tool_specified" >&5
12044 $as_echo "$as_me: Will use user supplied tool UNIQ=$tool_specified" >&6;}
12045           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNIQ" >&5
12046 $as_echo_n "checking for UNIQ... " >&6; }
12047           if test ! -x "$tool_specified"; then
12048             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12049 $as_echo "not found" >&6; }
12050             as_fn_error $? "User supplied tool UNIQ=$tool_specified does not exist or is not executable" "$LINENO" 5
12051           fi
12052           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12053 $as_echo "$tool_specified" >&6; }
12054         fi
12055       fi
12056     fi
12057 
12058   fi
12059 
12060 
12061 
12062   if test "x$UNIQ" = x; then
12063     as_fn_error $? "Could not find required tool for UNIQ" "$LINENO" 5
12064   fi
12065 
12066 
12067 
12068 
12069 
12070   # Publish this variable in the help.
12071 
12072 
12073   if [ -z "${WC+x}" ]; then
12074     # The variable is not set by user, try to locate tool using the code snippet
12075     for ac_prog in wc
12076 do
12077   # Extract the first word of "$ac_prog", so it can be a program name with args.
12078 set dummy $ac_prog; ac_word=$2
12079 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12080 $as_echo_n "checking for $ac_word... " >&6; }
12081 if ${ac_cv_path_WC+:} false; then :
12082   $as_echo_n "(cached) " >&6
12083 else
12084   case $WC in
12085   [\\/]* | ?:[\\/]*)
12086   ac_cv_path_WC="$WC" # Let the user override the test with a path.
12087   ;;
12088   *)
12089   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12090 for as_dir in $PATH
12091 do
12092   IFS=$as_save_IFS
12093   test -z "$as_dir" && as_dir=.
12094     for ac_exec_ext in '' $ac_executable_extensions; do
12095   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12096     ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
12097     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12098     break 2
12099   fi
12100 done
12101   done
12102 IFS=$as_save_IFS
12103 
12104   ;;
12105 esac
12106 fi
12107 WC=$ac_cv_path_WC
12108 if test -n "$WC"; then
12109   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
12110 $as_echo "$WC" >&6; }
12111 else
12112   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12113 $as_echo "no" >&6; }
12114 fi
12115 
12116 
12117   test -n "$WC" && break
12118 done
12119 
12120   else
12121     # The variable is set, but is it from the command line or the environment?
12122 
12123     # Try to remove the string !WC! from our list.
12124     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!WC!/}
12125     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12126       # If it failed, the variable was not from the command line. Ignore it,
12127       # but warn the user (except for BASH, which is always set by the calling BASH).
12128       if test "xWC" != xBASH; then
12129         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of WC from the environment. Use command line variables instead." >&5
12130 $as_echo "$as_me: WARNING: Ignoring value of WC from the environment. Use command line variables instead." >&2;}
12131       fi
12132       # Try to locate tool using the code snippet
12133       for ac_prog in wc
12134 do
12135   # Extract the first word of "$ac_prog", so it can be a program name with args.
12136 set dummy $ac_prog; ac_word=$2
12137 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12138 $as_echo_n "checking for $ac_word... " >&6; }
12139 if ${ac_cv_path_WC+:} false; then :
12140   $as_echo_n "(cached) " >&6
12141 else
12142   case $WC in
12143   [\\/]* | ?:[\\/]*)
12144   ac_cv_path_WC="$WC" # Let the user override the test with a path.
12145   ;;
12146   *)
12147   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12148 for as_dir in $PATH
12149 do
12150   IFS=$as_save_IFS
12151   test -z "$as_dir" && as_dir=.
12152     for ac_exec_ext in '' $ac_executable_extensions; do
12153   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12154     ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
12155     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12156     break 2
12157   fi
12158 done
12159   done
12160 IFS=$as_save_IFS
12161 
12162   ;;
12163 esac
12164 fi
12165 WC=$ac_cv_path_WC
12166 if test -n "$WC"; then
12167   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
12168 $as_echo "$WC" >&6; }
12169 else
12170   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12171 $as_echo "no" >&6; }
12172 fi
12173 
12174 
12175   test -n "$WC" && break
12176 done
12177 
12178     else
12179       # If it succeeded, then it was overridden by the user. We will use it
12180       # for the tool.
12181 
12182       # First remove it from the list of overridden variables, so we can test
12183       # for unknown variables in the end.
12184       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12185 
12186       # Check if we try to supply an empty value
12187       if test "x$WC" = x; then
12188         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool WC= (no value)" >&5
12189 $as_echo "$as_me: Setting user supplied tool WC= (no value)" >&6;}
12190         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WC" >&5
12191 $as_echo_n "checking for WC... " >&6; }
12192         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
12193 $as_echo "disabled" >&6; }
12194       else
12195         # Check if the provided tool contains a complete path.
12196         tool_specified="$WC"
12197         tool_basename="${tool_specified##*/}"
12198         if test "x$tool_basename" = "x$tool_specified"; then
12199           # A command without a complete path is provided, search $PATH.
12200           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool WC=$tool_basename" >&5
12201 $as_echo "$as_me: Will search for user supplied tool WC=$tool_basename" >&6;}
12202           # Extract the first word of "$tool_basename", so it can be a program name with args.
12203 set dummy $tool_basename; ac_word=$2
12204 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12205 $as_echo_n "checking for $ac_word... " >&6; }
12206 if ${ac_cv_path_WC+:} false; then :
12207   $as_echo_n "(cached) " >&6
12208 else
12209   case $WC in
12210   [\\/]* | ?:[\\/]*)
12211   ac_cv_path_WC="$WC" # Let the user override the test with a path.
12212   ;;
12213   *)
12214   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12215 for as_dir in $PATH
12216 do
12217   IFS=$as_save_IFS
12218   test -z "$as_dir" && as_dir=.
12219     for ac_exec_ext in '' $ac_executable_extensions; do
12220   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12221     ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
12222     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12223     break 2
12224   fi
12225 done
12226   done
12227 IFS=$as_save_IFS
12228 
12229   ;;
12230 esac
12231 fi
12232 WC=$ac_cv_path_WC
12233 if test -n "$WC"; then
12234   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
12235 $as_echo "$WC" >&6; }
12236 else
12237   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12238 $as_echo "no" >&6; }
12239 fi
12240 
12241 
12242           if test "x$WC" = x; then
12243             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12244           fi
12245         else
12246           # Otherwise we believe it is a complete path. Use it as it is.
12247           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool WC=$tool_specified" >&5
12248 $as_echo "$as_me: Will use user supplied tool WC=$tool_specified" >&6;}
12249           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WC" >&5
12250 $as_echo_n "checking for WC... " >&6; }
12251           if test ! -x "$tool_specified"; then
12252             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12253 $as_echo "not found" >&6; }
12254             as_fn_error $? "User supplied tool WC=$tool_specified does not exist or is not executable" "$LINENO" 5
12255           fi
12256           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12257 $as_echo "$tool_specified" >&6; }
12258         fi
12259       fi
12260     fi
12261 
12262   fi
12263 
12264 
12265 
12266   if test "x$WC" = x; then
12267     as_fn_error $? "Could not find required tool for WC" "$LINENO" 5
12268   fi
12269 
12270 
12271 
12272 
12273 
12274   # Publish this variable in the help.
12275 
12276 
12277   if [ -z "${WHICH+x}" ]; then
12278     # The variable is not set by user, try to locate tool using the code snippet
12279     for ac_prog in which
12280 do
12281   # Extract the first word of "$ac_prog", so it can be a program name with args.
12282 set dummy $ac_prog; ac_word=$2
12283 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12284 $as_echo_n "checking for $ac_word... " >&6; }
12285 if ${ac_cv_path_WHICH+:} false; then :
12286   $as_echo_n "(cached) " >&6
12287 else
12288   case $WHICH in
12289   [\\/]* | ?:[\\/]*)
12290   ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
12291   ;;
12292   *)
12293   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12294 for as_dir in $PATH
12295 do
12296   IFS=$as_save_IFS
12297   test -z "$as_dir" && as_dir=.
12298     for ac_exec_ext in '' $ac_executable_extensions; do
12299   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12300     ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
12301     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12302     break 2
12303   fi
12304 done
12305   done
12306 IFS=$as_save_IFS
12307 
12308   ;;
12309 esac
12310 fi
12311 WHICH=$ac_cv_path_WHICH
12312 if test -n "$WHICH"; then
12313   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
12314 $as_echo "$WHICH" >&6; }
12315 else
12316   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12317 $as_echo "no" >&6; }
12318 fi
12319 
12320 
12321   test -n "$WHICH" && break
12322 done
12323 
12324   else
12325     # The variable is set, but is it from the command line or the environment?
12326 
12327     # Try to remove the string !WHICH! from our list.
12328     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!WHICH!/}
12329     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12330       # If it failed, the variable was not from the command line. Ignore it,
12331       # but warn the user (except for BASH, which is always set by the calling BASH).
12332       if test "xWHICH" != xBASH; then
12333         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of WHICH from the environment. Use command line variables instead." >&5
12334 $as_echo "$as_me: WARNING: Ignoring value of WHICH from the environment. Use command line variables instead." >&2;}
12335       fi
12336       # Try to locate tool using the code snippet
12337       for ac_prog in which
12338 do
12339   # Extract the first word of "$ac_prog", so it can be a program name with args.
12340 set dummy $ac_prog; ac_word=$2
12341 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12342 $as_echo_n "checking for $ac_word... " >&6; }
12343 if ${ac_cv_path_WHICH+:} false; then :
12344   $as_echo_n "(cached) " >&6
12345 else
12346   case $WHICH in
12347   [\\/]* | ?:[\\/]*)
12348   ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
12349   ;;
12350   *)
12351   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12352 for as_dir in $PATH
12353 do
12354   IFS=$as_save_IFS
12355   test -z "$as_dir" && as_dir=.
12356     for ac_exec_ext in '' $ac_executable_extensions; do
12357   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12358     ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
12359     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12360     break 2
12361   fi
12362 done
12363   done
12364 IFS=$as_save_IFS
12365 
12366   ;;
12367 esac
12368 fi
12369 WHICH=$ac_cv_path_WHICH
12370 if test -n "$WHICH"; then
12371   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
12372 $as_echo "$WHICH" >&6; }
12373 else
12374   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12375 $as_echo "no" >&6; }
12376 fi
12377 
12378 
12379   test -n "$WHICH" && break
12380 done
12381 
12382     else
12383       # If it succeeded, then it was overridden by the user. We will use it
12384       # for the tool.
12385 
12386       # First remove it from the list of overridden variables, so we can test
12387       # for unknown variables in the end.
12388       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12389 
12390       # Check if we try to supply an empty value
12391       if test "x$WHICH" = x; then
12392         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool WHICH= (no value)" >&5
12393 $as_echo "$as_me: Setting user supplied tool WHICH= (no value)" >&6;}
12394         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WHICH" >&5
12395 $as_echo_n "checking for WHICH... " >&6; }
12396         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
12397 $as_echo "disabled" >&6; }
12398       else
12399         # Check if the provided tool contains a complete path.
12400         tool_specified="$WHICH"
12401         tool_basename="${tool_specified##*/}"
12402         if test "x$tool_basename" = "x$tool_specified"; then
12403           # A command without a complete path is provided, search $PATH.
12404           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool WHICH=$tool_basename" >&5
12405 $as_echo "$as_me: Will search for user supplied tool WHICH=$tool_basename" >&6;}
12406           # Extract the first word of "$tool_basename", so it can be a program name with args.
12407 set dummy $tool_basename; ac_word=$2
12408 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12409 $as_echo_n "checking for $ac_word... " >&6; }
12410 if ${ac_cv_path_WHICH+:} false; then :
12411   $as_echo_n "(cached) " >&6
12412 else
12413   case $WHICH in
12414   [\\/]* | ?:[\\/]*)
12415   ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
12416   ;;
12417   *)
12418   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12419 for as_dir in $PATH
12420 do
12421   IFS=$as_save_IFS
12422   test -z "$as_dir" && as_dir=.
12423     for ac_exec_ext in '' $ac_executable_extensions; do
12424   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12425     ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
12426     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12427     break 2
12428   fi
12429 done
12430   done
12431 IFS=$as_save_IFS
12432 
12433   ;;
12434 esac
12435 fi
12436 WHICH=$ac_cv_path_WHICH
12437 if test -n "$WHICH"; then
12438   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
12439 $as_echo "$WHICH" >&6; }
12440 else
12441   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12442 $as_echo "no" >&6; }
12443 fi
12444 
12445 
12446           if test "x$WHICH" = x; then
12447             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12448           fi
12449         else
12450           # Otherwise we believe it is a complete path. Use it as it is.
12451           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool WHICH=$tool_specified" >&5
12452 $as_echo "$as_me: Will use user supplied tool WHICH=$tool_specified" >&6;}
12453           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WHICH" >&5
12454 $as_echo_n "checking for WHICH... " >&6; }
12455           if test ! -x "$tool_specified"; then
12456             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12457 $as_echo "not found" >&6; }
12458             as_fn_error $? "User supplied tool WHICH=$tool_specified does not exist or is not executable" "$LINENO" 5
12459           fi
12460           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12461 $as_echo "$tool_specified" >&6; }
12462         fi
12463       fi
12464     fi
12465 
12466   fi
12467 
12468 
12469 
12470   if test "x$WHICH" = x; then
12471     as_fn_error $? "Could not find required tool for WHICH" "$LINENO" 5
12472   fi
12473 
12474 
12475 
12476 
12477 
12478   # Publish this variable in the help.
12479 
12480 
12481   if [ -z "${XARGS+x}" ]; then
12482     # The variable is not set by user, try to locate tool using the code snippet
12483     for ac_prog in xargs
12484 do
12485   # Extract the first word of "$ac_prog", so it can be a program name with args.
12486 set dummy $ac_prog; ac_word=$2
12487 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12488 $as_echo_n "checking for $ac_word... " >&6; }
12489 if ${ac_cv_path_XARGS+:} false; then :
12490   $as_echo_n "(cached) " >&6
12491 else
12492   case $XARGS in
12493   [\\/]* | ?:[\\/]*)
12494   ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
12495   ;;
12496   *)
12497   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12498 for as_dir in $PATH
12499 do
12500   IFS=$as_save_IFS
12501   test -z "$as_dir" && as_dir=.
12502     for ac_exec_ext in '' $ac_executable_extensions; do
12503   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12504     ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
12505     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12506     break 2
12507   fi
12508 done
12509   done
12510 IFS=$as_save_IFS
12511 
12512   ;;
12513 esac
12514 fi
12515 XARGS=$ac_cv_path_XARGS
12516 if test -n "$XARGS"; then
12517   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
12518 $as_echo "$XARGS" >&6; }
12519 else
12520   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12521 $as_echo "no" >&6; }
12522 fi
12523 
12524 
12525   test -n "$XARGS" && break
12526 done
12527 
12528   else
12529     # The variable is set, but is it from the command line or the environment?
12530 
12531     # Try to remove the string !XARGS! from our list.
12532     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!XARGS!/}
12533     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12534       # If it failed, the variable was not from the command line. Ignore it,
12535       # but warn the user (except for BASH, which is always set by the calling BASH).
12536       if test "xXARGS" != xBASH; then
12537         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of XARGS from the environment. Use command line variables instead." >&5
12538 $as_echo "$as_me: WARNING: Ignoring value of XARGS from the environment. Use command line variables instead." >&2;}
12539       fi
12540       # Try to locate tool using the code snippet
12541       for ac_prog in xargs
12542 do
12543   # Extract the first word of "$ac_prog", so it can be a program name with args.
12544 set dummy $ac_prog; ac_word=$2
12545 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12546 $as_echo_n "checking for $ac_word... " >&6; }
12547 if ${ac_cv_path_XARGS+:} false; then :
12548   $as_echo_n "(cached) " >&6
12549 else
12550   case $XARGS in
12551   [\\/]* | ?:[\\/]*)
12552   ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
12553   ;;
12554   *)
12555   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12556 for as_dir in $PATH
12557 do
12558   IFS=$as_save_IFS
12559   test -z "$as_dir" && as_dir=.
12560     for ac_exec_ext in '' $ac_executable_extensions; do
12561   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12562     ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
12563     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12564     break 2
12565   fi
12566 done
12567   done
12568 IFS=$as_save_IFS
12569 
12570   ;;
12571 esac
12572 fi
12573 XARGS=$ac_cv_path_XARGS
12574 if test -n "$XARGS"; then
12575   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
12576 $as_echo "$XARGS" >&6; }
12577 else
12578   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12579 $as_echo "no" >&6; }
12580 fi
12581 
12582 
12583   test -n "$XARGS" && break
12584 done
12585 
12586     else
12587       # If it succeeded, then it was overridden by the user. We will use it
12588       # for the tool.
12589 
12590       # First remove it from the list of overridden variables, so we can test
12591       # for unknown variables in the end.
12592       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12593 
12594       # Check if we try to supply an empty value
12595       if test "x$XARGS" = x; then
12596         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool XARGS= (no value)" >&5
12597 $as_echo "$as_me: Setting user supplied tool XARGS= (no value)" >&6;}
12598         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XARGS" >&5
12599 $as_echo_n "checking for XARGS... " >&6; }
12600         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
12601 $as_echo "disabled" >&6; }
12602       else
12603         # Check if the provided tool contains a complete path.
12604         tool_specified="$XARGS"
12605         tool_basename="${tool_specified##*/}"
12606         if test "x$tool_basename" = "x$tool_specified"; then
12607           # A command without a complete path is provided, search $PATH.
12608           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool XARGS=$tool_basename" >&5
12609 $as_echo "$as_me: Will search for user supplied tool XARGS=$tool_basename" >&6;}
12610           # Extract the first word of "$tool_basename", so it can be a program name with args.
12611 set dummy $tool_basename; ac_word=$2
12612 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12613 $as_echo_n "checking for $ac_word... " >&6; }
12614 if ${ac_cv_path_XARGS+:} false; then :
12615   $as_echo_n "(cached) " >&6
12616 else
12617   case $XARGS in
12618   [\\/]* | ?:[\\/]*)
12619   ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
12620   ;;
12621   *)
12622   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12623 for as_dir in $PATH
12624 do
12625   IFS=$as_save_IFS
12626   test -z "$as_dir" && as_dir=.
12627     for ac_exec_ext in '' $ac_executable_extensions; do
12628   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12629     ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
12630     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12631     break 2
12632   fi
12633 done
12634   done
12635 IFS=$as_save_IFS
12636 
12637   ;;
12638 esac
12639 fi
12640 XARGS=$ac_cv_path_XARGS
12641 if test -n "$XARGS"; then
12642   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
12643 $as_echo "$XARGS" >&6; }
12644 else
12645   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12646 $as_echo "no" >&6; }
12647 fi
12648 
12649 
12650           if test "x$XARGS" = x; then
12651             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12652           fi
12653         else
12654           # Otherwise we believe it is a complete path. Use it as it is.
12655           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool XARGS=$tool_specified" >&5
12656 $as_echo "$as_me: Will use user supplied tool XARGS=$tool_specified" >&6;}
12657           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XARGS" >&5
12658 $as_echo_n "checking for XARGS... " >&6; }
12659           if test ! -x "$tool_specified"; then
12660             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12661 $as_echo "not found" >&6; }
12662             as_fn_error $? "User supplied tool XARGS=$tool_specified does not exist or is not executable" "$LINENO" 5
12663           fi
12664           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12665 $as_echo "$tool_specified" >&6; }
12666         fi
12667       fi
12668     fi
12669 
12670   fi
12671 
12672 
12673 
12674   if test "x$XARGS" = x; then
12675     as_fn_error $? "Could not find required tool for XARGS" "$LINENO" 5
12676   fi
12677 
12678 
12679 
12680   # Then required tools that require some special treatment.
12681 
12682 
12683   # Publish this variable in the help.
12684 
12685 
12686   if [ -z "${AWK+x}" ]; then
12687     # The variable is not set by user, try to locate tool using the code snippet
12688     for ac_prog in gawk mawk nawk awk
12689 do
12690   # Extract the first word of "$ac_prog", so it can be a program name with args.
12691 set dummy $ac_prog; ac_word=$2
12692 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12693 $as_echo_n "checking for $ac_word... " >&6; }
12694 if ${ac_cv_prog_AWK+:} false; then :
12695   $as_echo_n "(cached) " >&6
12696 else
12697   if test -n "$AWK"; then
12698   ac_cv_prog_AWK="$AWK" # Let the user override the test.
12699 else
12700 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12701 for as_dir in $PATH
12702 do
12703   IFS=$as_save_IFS
12704   test -z "$as_dir" && as_dir=.
12705     for ac_exec_ext in '' $ac_executable_extensions; do
12706   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12707     ac_cv_prog_AWK="$ac_prog"
12708     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12709     break 2
12710   fi
12711 done
12712   done
12713 IFS=$as_save_IFS
12714 
12715 fi
12716 fi
12717 AWK=$ac_cv_prog_AWK
12718 if test -n "$AWK"; then
12719   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
12720 $as_echo "$AWK" >&6; }
12721 else
12722   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12723 $as_echo "no" >&6; }
12724 fi
12725 
12726 
12727   test -n "$AWK" && break
12728 done
12729 
12730   else
12731     # The variable is set, but is it from the command line or the environment?
12732 
12733     # Try to remove the string !AWK! from our list.
12734     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!AWK!/}
12735     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12736       # If it failed, the variable was not from the command line. Ignore it,
12737       # but warn the user (except for BASH, which is always set by the calling BASH).
12738       if test "xAWK" != xBASH; then
12739         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of AWK from the environment. Use command line variables instead." >&5
12740 $as_echo "$as_me: WARNING: Ignoring value of AWK from the environment. Use command line variables instead." >&2;}
12741       fi
12742       # Try to locate tool using the code snippet
12743       for ac_prog in gawk mawk nawk awk
12744 do
12745   # Extract the first word of "$ac_prog", so it can be a program name with args.
12746 set dummy $ac_prog; ac_word=$2
12747 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12748 $as_echo_n "checking for $ac_word... " >&6; }
12749 if ${ac_cv_prog_AWK+:} false; then :
12750   $as_echo_n "(cached) " >&6
12751 else
12752   if test -n "$AWK"; then
12753   ac_cv_prog_AWK="$AWK" # Let the user override the test.
12754 else
12755 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12756 for as_dir in $PATH
12757 do
12758   IFS=$as_save_IFS
12759   test -z "$as_dir" && as_dir=.
12760     for ac_exec_ext in '' $ac_executable_extensions; do
12761   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12762     ac_cv_prog_AWK="$ac_prog"
12763     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12764     break 2
12765   fi
12766 done
12767   done
12768 IFS=$as_save_IFS
12769 
12770 fi
12771 fi
12772 AWK=$ac_cv_prog_AWK
12773 if test -n "$AWK"; then
12774   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
12775 $as_echo "$AWK" >&6; }
12776 else
12777   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12778 $as_echo "no" >&6; }
12779 fi
12780 
12781 
12782   test -n "$AWK" && break
12783 done
12784 
12785     else
12786       # If it succeeded, then it was overridden by the user. We will use it
12787       # for the tool.
12788 
12789       # First remove it from the list of overridden variables, so we can test
12790       # for unknown variables in the end.
12791       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12792 
12793       # Check if we try to supply an empty value
12794       if test "x$AWK" = x; then
12795         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool AWK= (no value)" >&5
12796 $as_echo "$as_me: Setting user supplied tool AWK= (no value)" >&6;}
12797         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for AWK" >&5
12798 $as_echo_n "checking for AWK... " >&6; }
12799         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
12800 $as_echo "disabled" >&6; }
12801       else
12802         # Check if the provided tool contains a complete path.
12803         tool_specified="$AWK"
12804         tool_basename="${tool_specified##*/}"
12805         if test "x$tool_basename" = "x$tool_specified"; then
12806           # A command without a complete path is provided, search $PATH.
12807           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool AWK=$tool_basename" >&5
12808 $as_echo "$as_me: Will search for user supplied tool AWK=$tool_basename" >&6;}
12809           # Extract the first word of "$tool_basename", so it can be a program name with args.
12810 set dummy $tool_basename; ac_word=$2
12811 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12812 $as_echo_n "checking for $ac_word... " >&6; }
12813 if ${ac_cv_path_AWK+:} false; then :
12814   $as_echo_n "(cached) " >&6
12815 else
12816   case $AWK in
12817   [\\/]* | ?:[\\/]*)
12818   ac_cv_path_AWK="$AWK" # Let the user override the test with a path.
12819   ;;
12820   *)
12821   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12822 for as_dir in $PATH
12823 do
12824   IFS=$as_save_IFS
12825   test -z "$as_dir" && as_dir=.
12826     for ac_exec_ext in '' $ac_executable_extensions; do
12827   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12828     ac_cv_path_AWK="$as_dir/$ac_word$ac_exec_ext"
12829     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12830     break 2
12831   fi
12832 done
12833   done
12834 IFS=$as_save_IFS
12835 
12836   ;;
12837 esac
12838 fi
12839 AWK=$ac_cv_path_AWK
12840 if test -n "$AWK"; then
12841   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
12842 $as_echo "$AWK" >&6; }
12843 else
12844   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12845 $as_echo "no" >&6; }
12846 fi
12847 
12848 
12849           if test "x$AWK" = x; then
12850             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12851           fi
12852         else
12853           # Otherwise we believe it is a complete path. Use it as it is.
12854           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool AWK=$tool_specified" >&5
12855 $as_echo "$as_me: Will use user supplied tool AWK=$tool_specified" >&6;}
12856           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for AWK" >&5
12857 $as_echo_n "checking for AWK... " >&6; }
12858           if test ! -x "$tool_specified"; then
12859             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12860 $as_echo "not found" >&6; }
12861             as_fn_error $? "User supplied tool AWK=$tool_specified does not exist or is not executable" "$LINENO" 5
12862           fi
12863           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12864 $as_echo "$tool_specified" >&6; }
12865         fi
12866       fi
12867     fi
12868 
12869   fi
12870 
12871 
12872   if test "x$AWK" = x; then
12873     as_fn_error $? "Could not find required tool for AWK" "$LINENO" 5
12874   fi
12875 
12876 
12877 
12878 
12879   # Publish this variable in the help.
12880 
12881 
12882   if [ -z "${GREP+x}" ]; then
12883     # The variable is not set by user, try to locate tool using the code snippet
12884     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
12885 $as_echo_n "checking for grep that handles long lines and -e... " >&6; }
12886 if ${ac_cv_path_GREP+:} false; then :
12887   $as_echo_n "(cached) " >&6
12888 else
12889   if test -z "$GREP"; then
12890   ac_path_GREP_found=false
12891   # Loop through the user's path and test for each of PROGNAME-LIST
12892   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12893 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
12894 do
12895   IFS=$as_save_IFS
12896   test -z "$as_dir" && as_dir=.
12897     for ac_prog in grep ggrep; do
12898     for ac_exec_ext in '' $ac_executable_extensions; do
12899       ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
12900       as_fn_executable_p "$ac_path_GREP" || continue
12901 # Check for GNU ac_path_GREP and select it if it is found.
12902   # Check for GNU $ac_path_GREP
12903 case `"$ac_path_GREP" --version 2>&1` in
12904 *GNU*)
12905   ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
12906 *)
12907   ac_count=0
12908   $as_echo_n 0123456789 >"conftest.in"
12909   while :
12910   do
12911     cat "conftest.in" "conftest.in" >"conftest.tmp"
12912     mv "conftest.tmp" "conftest.in"
12913     cp "conftest.in" "conftest.nl"
12914     $as_echo 'GREP' >> "conftest.nl"
12915     "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
12916     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12917     as_fn_arith $ac_count + 1 && ac_count=$as_val
12918     if test $ac_count -gt ${ac_path_GREP_max-0}; then
12919       # Best one so far, save it but keep looking for a better one
12920       ac_cv_path_GREP="$ac_path_GREP"
12921       ac_path_GREP_max=$ac_count
12922     fi
12923     # 10*(2^10) chars as input seems more than enough
12924     test $ac_count -gt 10 && break
12925   done
12926   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12927 esac
12928 
12929       $ac_path_GREP_found && break 3
12930     done
12931   done
12932   done
12933 IFS=$as_save_IFS
12934   if test -z "$ac_cv_path_GREP"; then
12935     as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
12936   fi
12937 else
12938   ac_cv_path_GREP=$GREP
12939 fi
12940 
12941 fi
12942 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
12943 $as_echo "$ac_cv_path_GREP" >&6; }
12944  GREP="$ac_cv_path_GREP"
12945 
12946 
12947   else
12948     # The variable is set, but is it from the command line or the environment?
12949 
12950     # Try to remove the string !GREP! from our list.
12951     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!GREP!/}
12952     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12953       # If it failed, the variable was not from the command line. Ignore it,
12954       # but warn the user (except for BASH, which is always set by the calling BASH).
12955       if test "xGREP" != xBASH; then
12956         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of GREP from the environment. Use command line variables instead." >&5
12957 $as_echo "$as_me: WARNING: Ignoring value of GREP from the environment. Use command line variables instead." >&2;}
12958       fi
12959       # Try to locate tool using the code snippet
12960       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
12961 $as_echo_n "checking for grep that handles long lines and -e... " >&6; }
12962 if ${ac_cv_path_GREP+:} false; then :
12963   $as_echo_n "(cached) " >&6
12964 else
12965   if test -z "$GREP"; then
12966   ac_path_GREP_found=false
12967   # Loop through the user's path and test for each of PROGNAME-LIST
12968   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12969 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
12970 do
12971   IFS=$as_save_IFS
12972   test -z "$as_dir" && as_dir=.
12973     for ac_prog in grep ggrep; do
12974     for ac_exec_ext in '' $ac_executable_extensions; do
12975       ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
12976       as_fn_executable_p "$ac_path_GREP" || continue
12977 # Check for GNU ac_path_GREP and select it if it is found.
12978   # Check for GNU $ac_path_GREP
12979 case `"$ac_path_GREP" --version 2>&1` in
12980 *GNU*)
12981   ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
12982 *)
12983   ac_count=0
12984   $as_echo_n 0123456789 >"conftest.in"
12985   while :
12986   do
12987     cat "conftest.in" "conftest.in" >"conftest.tmp"
12988     mv "conftest.tmp" "conftest.in"
12989     cp "conftest.in" "conftest.nl"
12990     $as_echo 'GREP' >> "conftest.nl"
12991     "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
12992     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12993     as_fn_arith $ac_count + 1 && ac_count=$as_val
12994     if test $ac_count -gt ${ac_path_GREP_max-0}; then
12995       # Best one so far, save it but keep looking for a better one
12996       ac_cv_path_GREP="$ac_path_GREP"
12997       ac_path_GREP_max=$ac_count
12998     fi
12999     # 10*(2^10) chars as input seems more than enough
13000     test $ac_count -gt 10 && break
13001   done
13002   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
13003 esac
13004 
13005       $ac_path_GREP_found && break 3
13006     done
13007   done
13008   done
13009 IFS=$as_save_IFS
13010   if test -z "$ac_cv_path_GREP"; then
13011     as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
13012   fi
13013 else
13014   ac_cv_path_GREP=$GREP
13015 fi
13016 
13017 fi
13018 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
13019 $as_echo "$ac_cv_path_GREP" >&6; }
13020  GREP="$ac_cv_path_GREP"
13021 
13022 
13023     else
13024       # If it succeeded, then it was overridden by the user. We will use it
13025       # for the tool.
13026 
13027       # First remove it from the list of overridden variables, so we can test
13028       # for unknown variables in the end.
13029       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13030 
13031       # Check if we try to supply an empty value
13032       if test "x$GREP" = x; then
13033         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool GREP= (no value)" >&5
13034 $as_echo "$as_me: Setting user supplied tool GREP= (no value)" >&6;}
13035         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GREP" >&5
13036 $as_echo_n "checking for GREP... " >&6; }
13037         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
13038 $as_echo "disabled" >&6; }
13039       else
13040         # Check if the provided tool contains a complete path.
13041         tool_specified="$GREP"
13042         tool_basename="${tool_specified##*/}"
13043         if test "x$tool_basename" = "x$tool_specified"; then
13044           # A command without a complete path is provided, search $PATH.
13045           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool GREP=$tool_basename" >&5
13046 $as_echo "$as_me: Will search for user supplied tool GREP=$tool_basename" >&6;}
13047           # Extract the first word of "$tool_basename", so it can be a program name with args.
13048 set dummy $tool_basename; ac_word=$2
13049 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13050 $as_echo_n "checking for $ac_word... " >&6; }
13051 if ${ac_cv_path_GREP+:} false; then :
13052   $as_echo_n "(cached) " >&6
13053 else
13054   case $GREP in
13055   [\\/]* | ?:[\\/]*)
13056   ac_cv_path_GREP="$GREP" # Let the user override the test with a path.
13057   ;;
13058   *)
13059   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13060 for as_dir in $PATH
13061 do
13062   IFS=$as_save_IFS
13063   test -z "$as_dir" && as_dir=.
13064     for ac_exec_ext in '' $ac_executable_extensions; do
13065   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13066     ac_cv_path_GREP="$as_dir/$ac_word$ac_exec_ext"
13067     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13068     break 2
13069   fi
13070 done
13071   done
13072 IFS=$as_save_IFS
13073 
13074   ;;
13075 esac
13076 fi
13077 GREP=$ac_cv_path_GREP
13078 if test -n "$GREP"; then
13079   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GREP" >&5
13080 $as_echo "$GREP" >&6; }
13081 else
13082   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13083 $as_echo "no" >&6; }
13084 fi
13085 
13086 
13087           if test "x$GREP" = x; then
13088             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13089           fi
13090         else
13091           # Otherwise we believe it is a complete path. Use it as it is.
13092           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool GREP=$tool_specified" >&5
13093 $as_echo "$as_me: Will use user supplied tool GREP=$tool_specified" >&6;}
13094           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GREP" >&5
13095 $as_echo_n "checking for GREP... " >&6; }
13096           if test ! -x "$tool_specified"; then
13097             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13098 $as_echo "not found" >&6; }
13099             as_fn_error $? "User supplied tool GREP=$tool_specified does not exist or is not executable" "$LINENO" 5
13100           fi
13101           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13102 $as_echo "$tool_specified" >&6; }
13103         fi
13104       fi
13105     fi
13106 
13107   fi
13108 
13109 
13110   if test "x$GREP" = x; then
13111     as_fn_error $? "Could not find required tool for GREP" "$LINENO" 5
13112   fi
13113 
13114 
13115 
13116 
13117   # Publish this variable in the help.
13118 
13119 
13120   if [ -z "${EGREP+x}" ]; then
13121     # The variable is not set by user, try to locate tool using the code snippet
13122     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
13123 $as_echo_n "checking for egrep... " >&6; }
13124 if ${ac_cv_path_EGREP+:} false; then :
13125   $as_echo_n "(cached) " >&6
13126 else
13127   if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
13128    then ac_cv_path_EGREP="$GREP -E"
13129    else
13130      if test -z "$EGREP"; then
13131   ac_path_EGREP_found=false
13132   # Loop through the user's path and test for each of PROGNAME-LIST
13133   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13134 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
13135 do
13136   IFS=$as_save_IFS
13137   test -z "$as_dir" && as_dir=.
13138     for ac_prog in egrep; do
13139     for ac_exec_ext in '' $ac_executable_extensions; do
13140       ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
13141       as_fn_executable_p "$ac_path_EGREP" || continue
13142 # Check for GNU ac_path_EGREP and select it if it is found.
13143   # Check for GNU $ac_path_EGREP
13144 case `"$ac_path_EGREP" --version 2>&1` in
13145 *GNU*)
13146   ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
13147 *)
13148   ac_count=0
13149   $as_echo_n 0123456789 >"conftest.in"
13150   while :
13151   do
13152     cat "conftest.in" "conftest.in" >"conftest.tmp"
13153     mv "conftest.tmp" "conftest.in"
13154     cp "conftest.in" "conftest.nl"
13155     $as_echo 'EGREP' >> "conftest.nl"
13156     "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
13157     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
13158     as_fn_arith $ac_count + 1 && ac_count=$as_val
13159     if test $ac_count -gt ${ac_path_EGREP_max-0}; then
13160       # Best one so far, save it but keep looking for a better one
13161       ac_cv_path_EGREP="$ac_path_EGREP"
13162       ac_path_EGREP_max=$ac_count
13163     fi
13164     # 10*(2^10) chars as input seems more than enough
13165     test $ac_count -gt 10 && break
13166   done
13167   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
13168 esac
13169 
13170       $ac_path_EGREP_found && break 3
13171     done
13172   done
13173   done
13174 IFS=$as_save_IFS
13175   if test -z "$ac_cv_path_EGREP"; then
13176     as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
13177   fi
13178 else
13179   ac_cv_path_EGREP=$EGREP
13180 fi
13181 
13182    fi
13183 fi
13184 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
13185 $as_echo "$ac_cv_path_EGREP" >&6; }
13186  EGREP="$ac_cv_path_EGREP"
13187 
13188 
13189   else
13190     # The variable is set, but is it from the command line or the environment?
13191 
13192     # Try to remove the string !EGREP! from our list.
13193     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!EGREP!/}
13194     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
13195       # If it failed, the variable was not from the command line. Ignore it,
13196       # but warn the user (except for BASH, which is always set by the calling BASH).
13197       if test "xEGREP" != xBASH; then
13198         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of EGREP from the environment. Use command line variables instead." >&5
13199 $as_echo "$as_me: WARNING: Ignoring value of EGREP from the environment. Use command line variables instead." >&2;}
13200       fi
13201       # Try to locate tool using the code snippet
13202       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
13203 $as_echo_n "checking for egrep... " >&6; }
13204 if ${ac_cv_path_EGREP+:} false; then :
13205   $as_echo_n "(cached) " >&6
13206 else
13207   if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
13208    then ac_cv_path_EGREP="$GREP -E"
13209    else
13210      if test -z "$EGREP"; then
13211   ac_path_EGREP_found=false
13212   # Loop through the user's path and test for each of PROGNAME-LIST
13213   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13214 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
13215 do
13216   IFS=$as_save_IFS
13217   test -z "$as_dir" && as_dir=.
13218     for ac_prog in egrep; do
13219     for ac_exec_ext in '' $ac_executable_extensions; do
13220       ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
13221       as_fn_executable_p "$ac_path_EGREP" || continue
13222 # Check for GNU ac_path_EGREP and select it if it is found.
13223   # Check for GNU $ac_path_EGREP
13224 case `"$ac_path_EGREP" --version 2>&1` in
13225 *GNU*)
13226   ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
13227 *)
13228   ac_count=0
13229   $as_echo_n 0123456789 >"conftest.in"
13230   while :
13231   do
13232     cat "conftest.in" "conftest.in" >"conftest.tmp"
13233     mv "conftest.tmp" "conftest.in"
13234     cp "conftest.in" "conftest.nl"
13235     $as_echo 'EGREP' >> "conftest.nl"
13236     "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
13237     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
13238     as_fn_arith $ac_count + 1 && ac_count=$as_val
13239     if test $ac_count -gt ${ac_path_EGREP_max-0}; then
13240       # Best one so far, save it but keep looking for a better one
13241       ac_cv_path_EGREP="$ac_path_EGREP"
13242       ac_path_EGREP_max=$ac_count
13243     fi
13244     # 10*(2^10) chars as input seems more than enough
13245     test $ac_count -gt 10 && break
13246   done
13247   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
13248 esac
13249 
13250       $ac_path_EGREP_found && break 3
13251     done
13252   done
13253   done
13254 IFS=$as_save_IFS
13255   if test -z "$ac_cv_path_EGREP"; then
13256     as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
13257   fi
13258 else
13259   ac_cv_path_EGREP=$EGREP
13260 fi
13261 
13262    fi
13263 fi
13264 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
13265 $as_echo "$ac_cv_path_EGREP" >&6; }
13266  EGREP="$ac_cv_path_EGREP"
13267 
13268 
13269     else
13270       # If it succeeded, then it was overridden by the user. We will use it
13271       # for the tool.
13272 
13273       # First remove it from the list of overridden variables, so we can test
13274       # for unknown variables in the end.
13275       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13276 
13277       # Check if we try to supply an empty value
13278       if test "x$EGREP" = x; then
13279         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool EGREP= (no value)" >&5
13280 $as_echo "$as_me: Setting user supplied tool EGREP= (no value)" >&6;}
13281         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EGREP" >&5
13282 $as_echo_n "checking for EGREP... " >&6; }
13283         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
13284 $as_echo "disabled" >&6; }
13285       else
13286         # Check if the provided tool contains a complete path.
13287         tool_specified="$EGREP"
13288         tool_basename="${tool_specified##*/}"
13289         if test "x$tool_basename" = "x$tool_specified"; then
13290           # A command without a complete path is provided, search $PATH.
13291           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool EGREP=$tool_basename" >&5
13292 $as_echo "$as_me: Will search for user supplied tool EGREP=$tool_basename" >&6;}
13293           # Extract the first word of "$tool_basename", so it can be a program name with args.
13294 set dummy $tool_basename; ac_word=$2
13295 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13296 $as_echo_n "checking for $ac_word... " >&6; }
13297 if ${ac_cv_path_EGREP+:} false; then :
13298   $as_echo_n "(cached) " >&6
13299 else
13300   case $EGREP in
13301   [\\/]* | ?:[\\/]*)
13302   ac_cv_path_EGREP="$EGREP" # Let the user override the test with a path.
13303   ;;
13304   *)
13305   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13306 for as_dir in $PATH
13307 do
13308   IFS=$as_save_IFS
13309   test -z "$as_dir" && as_dir=.
13310     for ac_exec_ext in '' $ac_executable_extensions; do
13311   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13312     ac_cv_path_EGREP="$as_dir/$ac_word$ac_exec_ext"
13313     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13314     break 2
13315   fi
13316 done
13317   done
13318 IFS=$as_save_IFS
13319 
13320   ;;
13321 esac
13322 fi
13323 EGREP=$ac_cv_path_EGREP
13324 if test -n "$EGREP"; then
13325   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EGREP" >&5
13326 $as_echo "$EGREP" >&6; }
13327 else
13328   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13329 $as_echo "no" >&6; }
13330 fi
13331 
13332 
13333           if test "x$EGREP" = x; then
13334             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13335           fi
13336         else
13337           # Otherwise we believe it is a complete path. Use it as it is.
13338           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool EGREP=$tool_specified" >&5
13339 $as_echo "$as_me: Will use user supplied tool EGREP=$tool_specified" >&6;}
13340           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EGREP" >&5
13341 $as_echo_n "checking for EGREP... " >&6; }
13342           if test ! -x "$tool_specified"; then
13343             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13344 $as_echo "not found" >&6; }
13345             as_fn_error $? "User supplied tool EGREP=$tool_specified does not exist or is not executable" "$LINENO" 5
13346           fi
13347           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13348 $as_echo "$tool_specified" >&6; }
13349         fi
13350       fi
13351     fi
13352 
13353   fi
13354 
13355 
13356   if test "x$EGREP" = x; then
13357     as_fn_error $? "Could not find required tool for EGREP" "$LINENO" 5
13358   fi
13359 
13360 
13361 
13362 
13363   # Publish this variable in the help.
13364 
13365 
13366   if [ -z "${FGREP+x}" ]; then
13367     # The variable is not set by user, try to locate tool using the code snippet
13368     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
13369 $as_echo_n "checking for fgrep... " >&6; }
13370 if ${ac_cv_path_FGREP+:} false; then :
13371   $as_echo_n "(cached) " >&6
13372 else
13373   if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
13374    then ac_cv_path_FGREP="$GREP -F"
13375    else
13376      if test -z "$FGREP"; then
13377   ac_path_FGREP_found=false
13378   # Loop through the user's path and test for each of PROGNAME-LIST
13379   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13380 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
13381 do
13382   IFS=$as_save_IFS
13383   test -z "$as_dir" && as_dir=.
13384     for ac_prog in fgrep; do
13385     for ac_exec_ext in '' $ac_executable_extensions; do
13386       ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
13387       as_fn_executable_p "$ac_path_FGREP" || continue
13388 # Check for GNU ac_path_FGREP and select it if it is found.
13389   # Check for GNU $ac_path_FGREP
13390 case `"$ac_path_FGREP" --version 2>&1` in
13391 *GNU*)
13392   ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
13393 *)
13394   ac_count=0
13395   $as_echo_n 0123456789 >"conftest.in"
13396   while :
13397   do
13398     cat "conftest.in" "conftest.in" >"conftest.tmp"
13399     mv "conftest.tmp" "conftest.in"
13400     cp "conftest.in" "conftest.nl"
13401     $as_echo 'FGREP' >> "conftest.nl"
13402     "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
13403     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
13404     as_fn_arith $ac_count + 1 && ac_count=$as_val
13405     if test $ac_count -gt ${ac_path_FGREP_max-0}; then
13406       # Best one so far, save it but keep looking for a better one
13407       ac_cv_path_FGREP="$ac_path_FGREP"
13408       ac_path_FGREP_max=$ac_count
13409     fi
13410     # 10*(2^10) chars as input seems more than enough
13411     test $ac_count -gt 10 && break
13412   done
13413   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
13414 esac
13415 
13416       $ac_path_FGREP_found && break 3
13417     done
13418   done
13419   done
13420 IFS=$as_save_IFS
13421   if test -z "$ac_cv_path_FGREP"; then
13422     as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
13423   fi
13424 else
13425   ac_cv_path_FGREP=$FGREP
13426 fi
13427 
13428    fi
13429 fi
13430 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
13431 $as_echo "$ac_cv_path_FGREP" >&6; }
13432  FGREP="$ac_cv_path_FGREP"
13433 
13434 
13435   else
13436     # The variable is set, but is it from the command line or the environment?
13437 
13438     # Try to remove the string !FGREP! from our list.
13439     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FGREP!/}
13440     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
13441       # If it failed, the variable was not from the command line. Ignore it,
13442       # but warn the user (except for BASH, which is always set by the calling BASH).
13443       if test "xFGREP" != xBASH; then
13444         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FGREP from the environment. Use command line variables instead." >&5
13445 $as_echo "$as_me: WARNING: Ignoring value of FGREP from the environment. Use command line variables instead." >&2;}
13446       fi
13447       # Try to locate tool using the code snippet
13448       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
13449 $as_echo_n "checking for fgrep... " >&6; }
13450 if ${ac_cv_path_FGREP+:} false; then :
13451   $as_echo_n "(cached) " >&6
13452 else
13453   if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
13454    then ac_cv_path_FGREP="$GREP -F"
13455    else
13456      if test -z "$FGREP"; then
13457   ac_path_FGREP_found=false
13458   # Loop through the user's path and test for each of PROGNAME-LIST
13459   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13460 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
13461 do
13462   IFS=$as_save_IFS
13463   test -z "$as_dir" && as_dir=.
13464     for ac_prog in fgrep; do
13465     for ac_exec_ext in '' $ac_executable_extensions; do
13466       ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
13467       as_fn_executable_p "$ac_path_FGREP" || continue
13468 # Check for GNU ac_path_FGREP and select it if it is found.
13469   # Check for GNU $ac_path_FGREP
13470 case `"$ac_path_FGREP" --version 2>&1` in
13471 *GNU*)
13472   ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
13473 *)
13474   ac_count=0
13475   $as_echo_n 0123456789 >"conftest.in"
13476   while :
13477   do
13478     cat "conftest.in" "conftest.in" >"conftest.tmp"
13479     mv "conftest.tmp" "conftest.in"
13480     cp "conftest.in" "conftest.nl"
13481     $as_echo 'FGREP' >> "conftest.nl"
13482     "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
13483     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
13484     as_fn_arith $ac_count + 1 && ac_count=$as_val
13485     if test $ac_count -gt ${ac_path_FGREP_max-0}; then
13486       # Best one so far, save it but keep looking for a better one
13487       ac_cv_path_FGREP="$ac_path_FGREP"
13488       ac_path_FGREP_max=$ac_count
13489     fi
13490     # 10*(2^10) chars as input seems more than enough
13491     test $ac_count -gt 10 && break
13492   done
13493   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
13494 esac
13495 
13496       $ac_path_FGREP_found && break 3
13497     done
13498   done
13499   done
13500 IFS=$as_save_IFS
13501   if test -z "$ac_cv_path_FGREP"; then
13502     as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
13503   fi
13504 else
13505   ac_cv_path_FGREP=$FGREP
13506 fi
13507 
13508    fi
13509 fi
13510 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
13511 $as_echo "$ac_cv_path_FGREP" >&6; }
13512  FGREP="$ac_cv_path_FGREP"
13513 
13514 
13515     else
13516       # If it succeeded, then it was overridden by the user. We will use it
13517       # for the tool.
13518 
13519       # First remove it from the list of overridden variables, so we can test
13520       # for unknown variables in the end.
13521       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13522 
13523       # Check if we try to supply an empty value
13524       if test "x$FGREP" = x; then
13525         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool FGREP= (no value)" >&5
13526 $as_echo "$as_me: Setting user supplied tool FGREP= (no value)" >&6;}
13527         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FGREP" >&5
13528 $as_echo_n "checking for FGREP... " >&6; }
13529         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
13530 $as_echo "disabled" >&6; }
13531       else
13532         # Check if the provided tool contains a complete path.
13533         tool_specified="$FGREP"
13534         tool_basename="${tool_specified##*/}"
13535         if test "x$tool_basename" = "x$tool_specified"; then
13536           # A command without a complete path is provided, search $PATH.
13537           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FGREP=$tool_basename" >&5
13538 $as_echo "$as_me: Will search for user supplied tool FGREP=$tool_basename" >&6;}
13539           # Extract the first word of "$tool_basename", so it can be a program name with args.
13540 set dummy $tool_basename; ac_word=$2
13541 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13542 $as_echo_n "checking for $ac_word... " >&6; }
13543 if ${ac_cv_path_FGREP+:} false; then :
13544   $as_echo_n "(cached) " >&6
13545 else
13546   case $FGREP in
13547   [\\/]* | ?:[\\/]*)
13548   ac_cv_path_FGREP="$FGREP" # Let the user override the test with a path.
13549   ;;
13550   *)
13551   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13552 for as_dir in $PATH
13553 do
13554   IFS=$as_save_IFS
13555   test -z "$as_dir" && as_dir=.
13556     for ac_exec_ext in '' $ac_executable_extensions; do
13557   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13558     ac_cv_path_FGREP="$as_dir/$ac_word$ac_exec_ext"
13559     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13560     break 2
13561   fi
13562 done
13563   done
13564 IFS=$as_save_IFS
13565 
13566   ;;
13567 esac
13568 fi
13569 FGREP=$ac_cv_path_FGREP
13570 if test -n "$FGREP"; then
13571   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FGREP" >&5
13572 $as_echo "$FGREP" >&6; }
13573 else
13574   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13575 $as_echo "no" >&6; }
13576 fi
13577 
13578 
13579           if test "x$FGREP" = x; then
13580             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13581           fi
13582         else
13583           # Otherwise we believe it is a complete path. Use it as it is.
13584           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FGREP=$tool_specified" >&5
13585 $as_echo "$as_me: Will use user supplied tool FGREP=$tool_specified" >&6;}
13586           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FGREP" >&5
13587 $as_echo_n "checking for FGREP... " >&6; }
13588           if test ! -x "$tool_specified"; then
13589             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13590 $as_echo "not found" >&6; }
13591             as_fn_error $? "User supplied tool FGREP=$tool_specified does not exist or is not executable" "$LINENO" 5
13592           fi
13593           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13594 $as_echo "$tool_specified" >&6; }
13595         fi
13596       fi
13597     fi
13598 
13599   fi
13600 
13601 
13602   if test "x$FGREP" = x; then
13603     as_fn_error $? "Could not find required tool for FGREP" "$LINENO" 5
13604   fi
13605 
13606 
13607 
13608 
13609   # Publish this variable in the help.
13610 
13611 
13612   if [ -z "${SED+x}" ]; then
13613     # The variable is not set by user, try to locate tool using the code snippet
13614     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
13615 $as_echo_n "checking for a sed that does not truncate output... " >&6; }
13616 if ${ac_cv_path_SED+:} false; then :
13617   $as_echo_n "(cached) " >&6
13618 else
13619             ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
13620      for ac_i in 1 2 3 4 5 6 7; do
13621        ac_script="$ac_script$as_nl$ac_script"
13622      done
13623      echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
13624      { ac_script=; unset ac_script;}
13625      if test -z "$SED"; then
13626   ac_path_SED_found=false
13627   # Loop through the user's path and test for each of PROGNAME-LIST
13628   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13629 for as_dir in $PATH
13630 do
13631   IFS=$as_save_IFS
13632   test -z "$as_dir" && as_dir=.
13633     for ac_prog in sed gsed; do
13634     for ac_exec_ext in '' $ac_executable_extensions; do
13635       ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
13636       as_fn_executable_p "$ac_path_SED" || continue
13637 # Check for GNU ac_path_SED and select it if it is found.
13638   # Check for GNU $ac_path_SED
13639 case `"$ac_path_SED" --version 2>&1` in
13640 *GNU*)
13641   ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
13642 *)
13643   ac_count=0
13644   $as_echo_n 0123456789 >"conftest.in"
13645   while :
13646   do
13647     cat "conftest.in" "conftest.in" >"conftest.tmp"
13648     mv "conftest.tmp" "conftest.in"
13649     cp "conftest.in" "conftest.nl"
13650     $as_echo '' >> "conftest.nl"
13651     "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
13652     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
13653     as_fn_arith $ac_count + 1 && ac_count=$as_val
13654     if test $ac_count -gt ${ac_path_SED_max-0}; then
13655       # Best one so far, save it but keep looking for a better one
13656       ac_cv_path_SED="$ac_path_SED"
13657       ac_path_SED_max=$ac_count
13658     fi
13659     # 10*(2^10) chars as input seems more than enough
13660     test $ac_count -gt 10 && break
13661   done
13662   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
13663 esac
13664 
13665       $ac_path_SED_found && break 3
13666     done
13667   done
13668   done
13669 IFS=$as_save_IFS
13670   if test -z "$ac_cv_path_SED"; then
13671     as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
13672   fi
13673 else
13674   ac_cv_path_SED=$SED
13675 fi
13676 
13677 fi
13678 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
13679 $as_echo "$ac_cv_path_SED" >&6; }
13680  SED="$ac_cv_path_SED"
13681   rm -f conftest.sed
13682 
13683   else
13684     # The variable is set, but is it from the command line or the environment?
13685 
13686     # Try to remove the string !SED! from our list.
13687     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SED!/}
13688     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
13689       # If it failed, the variable was not from the command line. Ignore it,
13690       # but warn the user (except for BASH, which is always set by the calling BASH).
13691       if test "xSED" != xBASH; then
13692         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SED from the environment. Use command line variables instead." >&5
13693 $as_echo "$as_me: WARNING: Ignoring value of SED from the environment. Use command line variables instead." >&2;}
13694       fi
13695       # Try to locate tool using the code snippet
13696       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
13697 $as_echo_n "checking for a sed that does not truncate output... " >&6; }
13698 if ${ac_cv_path_SED+:} false; then :
13699   $as_echo_n "(cached) " >&6
13700 else
13701             ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
13702      for ac_i in 1 2 3 4 5 6 7; do
13703        ac_script="$ac_script$as_nl$ac_script"
13704      done
13705      echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
13706      { ac_script=; unset ac_script;}
13707      if test -z "$SED"; then
13708   ac_path_SED_found=false
13709   # Loop through the user's path and test for each of PROGNAME-LIST
13710   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13711 for as_dir in $PATH
13712 do
13713   IFS=$as_save_IFS
13714   test -z "$as_dir" && as_dir=.
13715     for ac_prog in sed gsed; do
13716     for ac_exec_ext in '' $ac_executable_extensions; do
13717       ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
13718       as_fn_executable_p "$ac_path_SED" || continue
13719 # Check for GNU ac_path_SED and select it if it is found.
13720   # Check for GNU $ac_path_SED
13721 case `"$ac_path_SED" --version 2>&1` in
13722 *GNU*)
13723   ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
13724 *)
13725   ac_count=0
13726   $as_echo_n 0123456789 >"conftest.in"
13727   while :
13728   do
13729     cat "conftest.in" "conftest.in" >"conftest.tmp"
13730     mv "conftest.tmp" "conftest.in"
13731     cp "conftest.in" "conftest.nl"
13732     $as_echo '' >> "conftest.nl"
13733     "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
13734     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
13735     as_fn_arith $ac_count + 1 && ac_count=$as_val
13736     if test $ac_count -gt ${ac_path_SED_max-0}; then
13737       # Best one so far, save it but keep looking for a better one
13738       ac_cv_path_SED="$ac_path_SED"
13739       ac_path_SED_max=$ac_count
13740     fi
13741     # 10*(2^10) chars as input seems more than enough
13742     test $ac_count -gt 10 && break
13743   done
13744   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
13745 esac
13746 
13747       $ac_path_SED_found && break 3
13748     done
13749   done
13750   done
13751 IFS=$as_save_IFS
13752   if test -z "$ac_cv_path_SED"; then
13753     as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
13754   fi
13755 else
13756   ac_cv_path_SED=$SED
13757 fi
13758 
13759 fi
13760 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
13761 $as_echo "$ac_cv_path_SED" >&6; }
13762  SED="$ac_cv_path_SED"
13763   rm -f conftest.sed
13764 
13765     else
13766       # If it succeeded, then it was overridden by the user. We will use it
13767       # for the tool.
13768 
13769       # First remove it from the list of overridden variables, so we can test
13770       # for unknown variables in the end.
13771       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13772 
13773       # Check if we try to supply an empty value
13774       if test "x$SED" = x; then
13775         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool SED= (no value)" >&5
13776 $as_echo "$as_me: Setting user supplied tool SED= (no value)" >&6;}
13777         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SED" >&5
13778 $as_echo_n "checking for SED... " >&6; }
13779         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
13780 $as_echo "disabled" >&6; }
13781       else
13782         # Check if the provided tool contains a complete path.
13783         tool_specified="$SED"
13784         tool_basename="${tool_specified##*/}"
13785         if test "x$tool_basename" = "x$tool_specified"; then
13786           # A command without a complete path is provided, search $PATH.
13787           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SED=$tool_basename" >&5
13788 $as_echo "$as_me: Will search for user supplied tool SED=$tool_basename" >&6;}
13789           # Extract the first word of "$tool_basename", so it can be a program name with args.
13790 set dummy $tool_basename; ac_word=$2
13791 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13792 $as_echo_n "checking for $ac_word... " >&6; }
13793 if ${ac_cv_path_SED+:} false; then :
13794   $as_echo_n "(cached) " >&6
13795 else
13796   case $SED in
13797   [\\/]* | ?:[\\/]*)
13798   ac_cv_path_SED="$SED" # Let the user override the test with a path.
13799   ;;
13800   *)
13801   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13802 for as_dir in $PATH
13803 do
13804   IFS=$as_save_IFS
13805   test -z "$as_dir" && as_dir=.
13806     for ac_exec_ext in '' $ac_executable_extensions; do
13807   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13808     ac_cv_path_SED="$as_dir/$ac_word$ac_exec_ext"
13809     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13810     break 2
13811   fi
13812 done
13813   done
13814 IFS=$as_save_IFS
13815 
13816   ;;
13817 esac
13818 fi
13819 SED=$ac_cv_path_SED
13820 if test -n "$SED"; then
13821   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SED" >&5
13822 $as_echo "$SED" >&6; }
13823 else
13824   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13825 $as_echo "no" >&6; }
13826 fi
13827 
13828 
13829           if test "x$SED" = x; then
13830             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13831           fi
13832         else
13833           # Otherwise we believe it is a complete path. Use it as it is.
13834           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SED=$tool_specified" >&5
13835 $as_echo "$as_me: Will use user supplied tool SED=$tool_specified" >&6;}
13836           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SED" >&5
13837 $as_echo_n "checking for SED... " >&6; }
13838           if test ! -x "$tool_specified"; then
13839             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13840 $as_echo "not found" >&6; }
13841             as_fn_error $? "User supplied tool SED=$tool_specified does not exist or is not executable" "$LINENO" 5
13842           fi
13843           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13844 $as_echo "$tool_specified" >&6; }
13845         fi
13846       fi
13847     fi
13848 
13849   fi
13850 
13851 
13852   if test "x$SED" = x; then
13853     as_fn_error $? "Could not find required tool for SED" "$LINENO" 5
13854   fi
13855 
13856 
13857 
13858   # Always force rm.
13859   RM="$RM -f"
13860 
13861   # pwd behaves differently on various platforms and some don't support the -L flag.
13862   # Always use the bash builtin pwd to get uniform behavior.
13863   THEPWDCMD=pwd
13864 
13865   # These are not required on all platforms
13866 
13867 
13868   # Publish this variable in the help.
13869 
13870 
13871   if [ -z "${CYGPATH+x}" ]; then
13872     # The variable is not set by user, try to locate tool using the code snippet
13873     for ac_prog in cygpath
13874 do
13875   # Extract the first word of "$ac_prog", so it can be a program name with args.
13876 set dummy $ac_prog; ac_word=$2
13877 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13878 $as_echo_n "checking for $ac_word... " >&6; }
13879 if ${ac_cv_path_CYGPATH+:} false; then :
13880   $as_echo_n "(cached) " >&6
13881 else
13882   case $CYGPATH in
13883   [\\/]* | ?:[\\/]*)
13884   ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
13885   ;;
13886   *)
13887   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13888 for as_dir in $PATH
13889 do
13890   IFS=$as_save_IFS
13891   test -z "$as_dir" && as_dir=.
13892     for ac_exec_ext in '' $ac_executable_extensions; do
13893   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13894     ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
13895     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13896     break 2
13897   fi
13898 done
13899   done
13900 IFS=$as_save_IFS
13901 
13902   ;;
13903 esac
13904 fi
13905 CYGPATH=$ac_cv_path_CYGPATH
13906 if test -n "$CYGPATH"; then
13907   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
13908 $as_echo "$CYGPATH" >&6; }
13909 else
13910   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13911 $as_echo "no" >&6; }
13912 fi
13913 
13914 
13915   test -n "$CYGPATH" && break
13916 done
13917 
13918   else
13919     # The variable is set, but is it from the command line or the environment?
13920 
13921     # Try to remove the string !CYGPATH! from our list.
13922     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CYGPATH!/}
13923     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
13924       # If it failed, the variable was not from the command line. Ignore it,
13925       # but warn the user (except for BASH, which is always set by the calling BASH).
13926       if test "xCYGPATH" != xBASH; then
13927         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CYGPATH from the environment. Use command line variables instead." >&5
13928 $as_echo "$as_me: WARNING: Ignoring value of CYGPATH from the environment. Use command line variables instead." >&2;}
13929       fi
13930       # Try to locate tool using the code snippet
13931       for ac_prog in cygpath
13932 do
13933   # Extract the first word of "$ac_prog", so it can be a program name with args.
13934 set dummy $ac_prog; ac_word=$2
13935 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13936 $as_echo_n "checking for $ac_word... " >&6; }
13937 if ${ac_cv_path_CYGPATH+:} false; then :
13938   $as_echo_n "(cached) " >&6
13939 else
13940   case $CYGPATH in
13941   [\\/]* | ?:[\\/]*)
13942   ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
13943   ;;
13944   *)
13945   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13946 for as_dir in $PATH
13947 do
13948   IFS=$as_save_IFS
13949   test -z "$as_dir" && as_dir=.
13950     for ac_exec_ext in '' $ac_executable_extensions; do
13951   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13952     ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
13953     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13954     break 2
13955   fi
13956 done
13957   done
13958 IFS=$as_save_IFS
13959 
13960   ;;
13961 esac
13962 fi
13963 CYGPATH=$ac_cv_path_CYGPATH
13964 if test -n "$CYGPATH"; then
13965   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
13966 $as_echo "$CYGPATH" >&6; }
13967 else
13968   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13969 $as_echo "no" >&6; }
13970 fi
13971 
13972 
13973   test -n "$CYGPATH" && break
13974 done
13975 
13976     else
13977       # If it succeeded, then it was overridden by the user. We will use it
13978       # for the tool.
13979 
13980       # First remove it from the list of overridden variables, so we can test
13981       # for unknown variables in the end.
13982       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13983 
13984       # Check if we try to supply an empty value
13985       if test "x$CYGPATH" = x; then
13986         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CYGPATH= (no value)" >&5
13987 $as_echo "$as_me: Setting user supplied tool CYGPATH= (no value)" >&6;}
13988         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CYGPATH" >&5
13989 $as_echo_n "checking for CYGPATH... " >&6; }
13990         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
13991 $as_echo "disabled" >&6; }
13992       else
13993         # Check if the provided tool contains a complete path.
13994         tool_specified="$CYGPATH"
13995         tool_basename="${tool_specified##*/}"
13996         if test "x$tool_basename" = "x$tool_specified"; then
13997           # A command without a complete path is provided, search $PATH.
13998           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CYGPATH=$tool_basename" >&5
13999 $as_echo "$as_me: Will search for user supplied tool CYGPATH=$tool_basename" >&6;}
14000           # Extract the first word of "$tool_basename", so it can be a program name with args.
14001 set dummy $tool_basename; ac_word=$2
14002 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14003 $as_echo_n "checking for $ac_word... " >&6; }
14004 if ${ac_cv_path_CYGPATH+:} false; then :
14005   $as_echo_n "(cached) " >&6
14006 else
14007   case $CYGPATH in
14008   [\\/]* | ?:[\\/]*)
14009   ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
14010   ;;
14011   *)
14012   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14013 for as_dir in $PATH
14014 do
14015   IFS=$as_save_IFS
14016   test -z "$as_dir" && as_dir=.
14017     for ac_exec_ext in '' $ac_executable_extensions; do
14018   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14019     ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
14020     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14021     break 2
14022   fi
14023 done
14024   done
14025 IFS=$as_save_IFS
14026 
14027   ;;
14028 esac
14029 fi
14030 CYGPATH=$ac_cv_path_CYGPATH
14031 if test -n "$CYGPATH"; then
14032   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
14033 $as_echo "$CYGPATH" >&6; }
14034 else
14035   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14036 $as_echo "no" >&6; }
14037 fi
14038 
14039 
14040           if test "x$CYGPATH" = x; then
14041             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
14042           fi
14043         else
14044           # Otherwise we believe it is a complete path. Use it as it is.
14045           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CYGPATH=$tool_specified" >&5
14046 $as_echo "$as_me: Will use user supplied tool CYGPATH=$tool_specified" >&6;}
14047           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CYGPATH" >&5
14048 $as_echo_n "checking for CYGPATH... " >&6; }
14049           if test ! -x "$tool_specified"; then
14050             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
14051 $as_echo "not found" >&6; }
14052             as_fn_error $? "User supplied tool CYGPATH=$tool_specified does not exist or is not executable" "$LINENO" 5
14053           fi
14054           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
14055 $as_echo "$tool_specified" >&6; }
14056         fi
14057       fi
14058     fi
14059 
14060   fi
14061 
14062 
14063 
14064 
14065   # Publish this variable in the help.
14066 
14067 
14068   if [ -z "${READLINK+x}" ]; then
14069     # The variable is not set by user, try to locate tool using the code snippet
14070     for ac_prog in greadlink readlink
14071 do
14072   # Extract the first word of "$ac_prog", so it can be a program name with args.
14073 set dummy $ac_prog; ac_word=$2
14074 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14075 $as_echo_n "checking for $ac_word... " >&6; }
14076 if ${ac_cv_path_READLINK+:} false; then :
14077   $as_echo_n "(cached) " >&6
14078 else
14079   case $READLINK in
14080   [\\/]* | ?:[\\/]*)
14081   ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
14082   ;;
14083   *)
14084   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14085 for as_dir in $PATH
14086 do
14087   IFS=$as_save_IFS
14088   test -z "$as_dir" && as_dir=.
14089     for ac_exec_ext in '' $ac_executable_extensions; do
14090   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14091     ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
14092     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14093     break 2
14094   fi
14095 done
14096   done
14097 IFS=$as_save_IFS
14098 
14099   ;;
14100 esac
14101 fi
14102 READLINK=$ac_cv_path_READLINK
14103 if test -n "$READLINK"; then
14104   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
14105 $as_echo "$READLINK" >&6; }
14106 else
14107   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14108 $as_echo "no" >&6; }
14109 fi
14110 
14111 
14112   test -n "$READLINK" && break
14113 done
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 !READLINK! from our list.
14119     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!READLINK!/}
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 "xREADLINK" != xBASH; then
14124         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of READLINK from the environment. Use command line variables instead." >&5
14125 $as_echo "$as_me: WARNING: Ignoring value of READLINK from the environment. Use command line variables instead." >&2;}
14126       fi
14127       # Try to locate tool using the code snippet
14128       for ac_prog in greadlink readlink
14129 do
14130   # Extract the first word of "$ac_prog", so it can be a program name with args.
14131 set dummy $ac_prog; ac_word=$2
14132 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14133 $as_echo_n "checking for $ac_word... " >&6; }
14134 if ${ac_cv_path_READLINK+:} false; then :
14135   $as_echo_n "(cached) " >&6
14136 else
14137   case $READLINK in
14138   [\\/]* | ?:[\\/]*)
14139   ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
14140   ;;
14141   *)
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_exec_ext in '' $ac_executable_extensions; do
14148   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14149     ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
14150     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14151     break 2
14152   fi
14153 done
14154   done
14155 IFS=$as_save_IFS
14156 
14157   ;;
14158 esac
14159 fi
14160 READLINK=$ac_cv_path_READLINK
14161 if test -n "$READLINK"; then
14162   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
14163 $as_echo "$READLINK" >&6; }
14164 else
14165   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14166 $as_echo "no" >&6; }
14167 fi
14168 
14169 
14170   test -n "$READLINK" && break
14171 done
14172 
14173     else
14174       # If it succeeded, then it was overridden by the user. We will use it
14175       # for the tool.
14176 
14177       # First remove it from the list of overridden variables, so we can test
14178       # for unknown variables in the end.
14179       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
14180 
14181       # Check if we try to supply an empty value
14182       if test "x$READLINK" = x; then
14183         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool READLINK= (no value)" >&5
14184 $as_echo "$as_me: Setting user supplied tool READLINK= (no value)" >&6;}
14185         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READLINK" >&5
14186 $as_echo_n "checking for READLINK... " >&6; }
14187         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
14188 $as_echo "disabled" >&6; }
14189       else
14190         # Check if the provided tool contains a complete path.
14191         tool_specified="$READLINK"
14192         tool_basename="${tool_specified##*/}"
14193         if test "x$tool_basename" = "x$tool_specified"; then
14194           # A command without a complete path is provided, search $PATH.
14195           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool READLINK=$tool_basename" >&5
14196 $as_echo "$as_me: Will search for user supplied tool READLINK=$tool_basename" >&6;}
14197           # Extract the first word of "$tool_basename", so it can be a program name with args.
14198 set dummy $tool_basename; ac_word=$2
14199 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14200 $as_echo_n "checking for $ac_word... " >&6; }
14201 if ${ac_cv_path_READLINK+:} false; then :
14202   $as_echo_n "(cached) " >&6
14203 else
14204   case $READLINK in
14205   [\\/]* | ?:[\\/]*)
14206   ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
14207   ;;
14208   *)
14209   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14210 for as_dir in $PATH
14211 do
14212   IFS=$as_save_IFS
14213   test -z "$as_dir" && as_dir=.
14214     for ac_exec_ext in '' $ac_executable_extensions; do
14215   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14216     ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
14217     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14218     break 2
14219   fi
14220 done
14221   done
14222 IFS=$as_save_IFS
14223 
14224   ;;
14225 esac
14226 fi
14227 READLINK=$ac_cv_path_READLINK
14228 if test -n "$READLINK"; then
14229   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
14230 $as_echo "$READLINK" >&6; }
14231 else
14232   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14233 $as_echo "no" >&6; }
14234 fi
14235 
14236 
14237           if test "x$READLINK" = x; then
14238             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
14239           fi
14240         else
14241           # Otherwise we believe it is a complete path. Use it as it is.
14242           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool READLINK=$tool_specified" >&5
14243 $as_echo "$as_me: Will use user supplied tool READLINK=$tool_specified" >&6;}
14244           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READLINK" >&5
14245 $as_echo_n "checking for READLINK... " >&6; }
14246           if test ! -x "$tool_specified"; then
14247             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
14248 $as_echo "not found" >&6; }
14249             as_fn_error $? "User supplied tool READLINK=$tool_specified does not exist or is not executable" "$LINENO" 5
14250           fi
14251           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
14252 $as_echo "$tool_specified" >&6; }
14253         fi
14254       fi
14255     fi
14256 
14257   fi
14258 
14259 
14260 
14261 
14262   # Publish this variable in the help.
14263 
14264 
14265   if [ -z "${DF+x}" ]; then
14266     # The variable is not set by user, try to locate tool using the code snippet
14267     for ac_prog in df
14268 do
14269   # Extract the first word of "$ac_prog", so it can be a program name with args.
14270 set dummy $ac_prog; ac_word=$2
14271 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14272 $as_echo_n "checking for $ac_word... " >&6; }
14273 if ${ac_cv_path_DF+:} false; then :
14274   $as_echo_n "(cached) " >&6
14275 else
14276   case $DF in
14277   [\\/]* | ?:[\\/]*)
14278   ac_cv_path_DF="$DF" # Let the user override the test with a path.
14279   ;;
14280   *)
14281   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14282 for as_dir in $PATH
14283 do
14284   IFS=$as_save_IFS
14285   test -z "$as_dir" && as_dir=.
14286     for ac_exec_ext in '' $ac_executable_extensions; do
14287   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14288     ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
14289     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14290     break 2
14291   fi
14292 done
14293   done
14294 IFS=$as_save_IFS
14295 
14296   ;;
14297 esac
14298 fi
14299 DF=$ac_cv_path_DF
14300 if test -n "$DF"; then
14301   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
14302 $as_echo "$DF" >&6; }
14303 else
14304   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14305 $as_echo "no" >&6; }
14306 fi
14307 
14308 
14309   test -n "$DF" && break
14310 done
14311 
14312   else
14313     # The variable is set, but is it from the command line or the environment?
14314 
14315     # Try to remove the string !DF! from our list.
14316     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DF!/}
14317     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
14318       # If it failed, the variable was not from the command line. Ignore it,
14319       # but warn the user (except for BASH, which is always set by the calling BASH).
14320       if test "xDF" != xBASH; then
14321         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DF from the environment. Use command line variables instead." >&5
14322 $as_echo "$as_me: WARNING: Ignoring value of DF from the environment. Use command line variables instead." >&2;}
14323       fi
14324       # Try to locate tool using the code snippet
14325       for ac_prog in df
14326 do
14327   # Extract the first word of "$ac_prog", so it can be a program name with args.
14328 set dummy $ac_prog; ac_word=$2
14329 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14330 $as_echo_n "checking for $ac_word... " >&6; }
14331 if ${ac_cv_path_DF+:} false; then :
14332   $as_echo_n "(cached) " >&6
14333 else
14334   case $DF in
14335   [\\/]* | ?:[\\/]*)
14336   ac_cv_path_DF="$DF" # Let the user override the test with a path.
14337   ;;
14338   *)
14339   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14340 for as_dir in $PATH
14341 do
14342   IFS=$as_save_IFS
14343   test -z "$as_dir" && as_dir=.
14344     for ac_exec_ext in '' $ac_executable_extensions; do
14345   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14346     ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
14347     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14348     break 2
14349   fi
14350 done
14351   done
14352 IFS=$as_save_IFS
14353 
14354   ;;
14355 esac
14356 fi
14357 DF=$ac_cv_path_DF
14358 if test -n "$DF"; then
14359   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
14360 $as_echo "$DF" >&6; }
14361 else
14362   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14363 $as_echo "no" >&6; }
14364 fi
14365 
14366 
14367   test -n "$DF" && break
14368 done
14369 
14370     else
14371       # If it succeeded, then it was overridden by the user. We will use it
14372       # for the tool.
14373 
14374       # First remove it from the list of overridden variables, so we can test
14375       # for unknown variables in the end.
14376       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
14377 
14378       # Check if we try to supply an empty value
14379       if test "x$DF" = x; then
14380         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool DF= (no value)" >&5
14381 $as_echo "$as_me: Setting user supplied tool DF= (no value)" >&6;}
14382         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DF" >&5
14383 $as_echo_n "checking for DF... " >&6; }
14384         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
14385 $as_echo "disabled" >&6; }
14386       else
14387         # Check if the provided tool contains a complete path.
14388         tool_specified="$DF"
14389         tool_basename="${tool_specified##*/}"
14390         if test "x$tool_basename" = "x$tool_specified"; then
14391           # A command without a complete path is provided, search $PATH.
14392           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DF=$tool_basename" >&5
14393 $as_echo "$as_me: Will search for user supplied tool DF=$tool_basename" >&6;}
14394           # Extract the first word of "$tool_basename", so it can be a program name with args.
14395 set dummy $tool_basename; ac_word=$2
14396 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14397 $as_echo_n "checking for $ac_word... " >&6; }
14398 if ${ac_cv_path_DF+:} false; then :
14399   $as_echo_n "(cached) " >&6
14400 else
14401   case $DF in
14402   [\\/]* | ?:[\\/]*)
14403   ac_cv_path_DF="$DF" # Let the user override the test with a path.
14404   ;;
14405   *)
14406   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14407 for as_dir in $PATH
14408 do
14409   IFS=$as_save_IFS
14410   test -z "$as_dir" && as_dir=.
14411     for ac_exec_ext in '' $ac_executable_extensions; do
14412   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14413     ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
14414     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14415     break 2
14416   fi
14417 done
14418   done
14419 IFS=$as_save_IFS
14420 
14421   ;;
14422 esac
14423 fi
14424 DF=$ac_cv_path_DF
14425 if test -n "$DF"; then
14426   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
14427 $as_echo "$DF" >&6; }
14428 else
14429   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14430 $as_echo "no" >&6; }
14431 fi
14432 
14433 
14434           if test "x$DF" = x; then
14435             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
14436           fi
14437         else
14438           # Otherwise we believe it is a complete path. Use it as it is.
14439           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DF=$tool_specified" >&5
14440 $as_echo "$as_me: Will use user supplied tool DF=$tool_specified" >&6;}
14441           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DF" >&5
14442 $as_echo_n "checking for DF... " >&6; }
14443           if test ! -x "$tool_specified"; then
14444             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
14445 $as_echo "not found" >&6; }
14446             as_fn_error $? "User supplied tool DF=$tool_specified does not exist or is not executable" "$LINENO" 5
14447           fi
14448           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
14449 $as_echo "$tool_specified" >&6; }
14450         fi
14451       fi
14452     fi
14453 
14454   fi
14455 
14456 
14457 
14458 
14459   # Publish this variable in the help.
14460 
14461 
14462   if [ -z "${CPIO+x}" ]; then
14463     # The variable is not set by user, try to locate tool using the code snippet
14464     for ac_prog in cpio bsdcpio
14465 do
14466   # Extract the first word of "$ac_prog", so it can be a program name with args.
14467 set dummy $ac_prog; ac_word=$2
14468 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14469 $as_echo_n "checking for $ac_word... " >&6; }
14470 if ${ac_cv_path_CPIO+:} false; then :
14471   $as_echo_n "(cached) " >&6
14472 else
14473   case $CPIO in
14474   [\\/]* | ?:[\\/]*)
14475   ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
14476   ;;
14477   *)
14478   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14479 for as_dir in $PATH
14480 do
14481   IFS=$as_save_IFS
14482   test -z "$as_dir" && as_dir=.
14483     for ac_exec_ext in '' $ac_executable_extensions; do
14484   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14485     ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
14486     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14487     break 2
14488   fi
14489 done
14490   done
14491 IFS=$as_save_IFS
14492 
14493   ;;
14494 esac
14495 fi
14496 CPIO=$ac_cv_path_CPIO
14497 if test -n "$CPIO"; then
14498   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
14499 $as_echo "$CPIO" >&6; }
14500 else
14501   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14502 $as_echo "no" >&6; }
14503 fi
14504 
14505 
14506   test -n "$CPIO" && break
14507 done
14508 
14509   else
14510     # The variable is set, but is it from the command line or the environment?
14511 
14512     # Try to remove the string !CPIO! from our list.
14513     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CPIO!/}
14514     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
14515       # If it failed, the variable was not from the command line. Ignore it,
14516       # but warn the user (except for BASH, which is always set by the calling BASH).
14517       if test "xCPIO" != xBASH; then
14518         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CPIO from the environment. Use command line variables instead." >&5
14519 $as_echo "$as_me: WARNING: Ignoring value of CPIO from the environment. Use command line variables instead." >&2;}
14520       fi
14521       # Try to locate tool using the code snippet
14522       for ac_prog in cpio bsdcpio
14523 do
14524   # Extract the first word of "$ac_prog", so it can be a program name with args.
14525 set dummy $ac_prog; ac_word=$2
14526 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14527 $as_echo_n "checking for $ac_word... " >&6; }
14528 if ${ac_cv_path_CPIO+:} false; then :
14529   $as_echo_n "(cached) " >&6
14530 else
14531   case $CPIO in
14532   [\\/]* | ?:[\\/]*)
14533   ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
14534   ;;
14535   *)
14536   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14537 for as_dir in $PATH
14538 do
14539   IFS=$as_save_IFS
14540   test -z "$as_dir" && as_dir=.
14541     for ac_exec_ext in '' $ac_executable_extensions; do
14542   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14543     ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
14544     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14545     break 2
14546   fi
14547 done
14548   done
14549 IFS=$as_save_IFS
14550 
14551   ;;
14552 esac
14553 fi
14554 CPIO=$ac_cv_path_CPIO
14555 if test -n "$CPIO"; then
14556   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
14557 $as_echo "$CPIO" >&6; }
14558 else
14559   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14560 $as_echo "no" >&6; }
14561 fi
14562 
14563 
14564   test -n "$CPIO" && break
14565 done
14566 
14567     else
14568       # If it succeeded, then it was overridden by the user. We will use it
14569       # for the tool.
14570 
14571       # First remove it from the list of overridden variables, so we can test
14572       # for unknown variables in the end.
14573       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
14574 
14575       # Check if we try to supply an empty value
14576       if test "x$CPIO" = x; then
14577         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CPIO= (no value)" >&5
14578 $as_echo "$as_me: Setting user supplied tool CPIO= (no value)" >&6;}
14579         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CPIO" >&5
14580 $as_echo_n "checking for CPIO... " >&6; }
14581         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
14582 $as_echo "disabled" >&6; }
14583       else
14584         # Check if the provided tool contains a complete path.
14585         tool_specified="$CPIO"
14586         tool_basename="${tool_specified##*/}"
14587         if test "x$tool_basename" = "x$tool_specified"; then
14588           # A command without a complete path is provided, search $PATH.
14589           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CPIO=$tool_basename" >&5
14590 $as_echo "$as_me: Will search for user supplied tool CPIO=$tool_basename" >&6;}
14591           # Extract the first word of "$tool_basename", so it can be a program name with args.
14592 set dummy $tool_basename; ac_word=$2
14593 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14594 $as_echo_n "checking for $ac_word... " >&6; }
14595 if ${ac_cv_path_CPIO+:} false; then :
14596   $as_echo_n "(cached) " >&6
14597 else
14598   case $CPIO in
14599   [\\/]* | ?:[\\/]*)
14600   ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
14601   ;;
14602   *)
14603   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14604 for as_dir in $PATH
14605 do
14606   IFS=$as_save_IFS
14607   test -z "$as_dir" && as_dir=.
14608     for ac_exec_ext in '' $ac_executable_extensions; do
14609   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14610     ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
14611     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14612     break 2
14613   fi
14614 done
14615   done
14616 IFS=$as_save_IFS
14617 
14618   ;;
14619 esac
14620 fi
14621 CPIO=$ac_cv_path_CPIO
14622 if test -n "$CPIO"; then
14623   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
14624 $as_echo "$CPIO" >&6; }
14625 else
14626   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14627 $as_echo "no" >&6; }
14628 fi
14629 
14630 
14631           if test "x$CPIO" = x; then
14632             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
14633           fi
14634         else
14635           # Otherwise we believe it is a complete path. Use it as it is.
14636           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CPIO=$tool_specified" >&5
14637 $as_echo "$as_me: Will use user supplied tool CPIO=$tool_specified" >&6;}
14638           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CPIO" >&5
14639 $as_echo_n "checking for CPIO... " >&6; }
14640           if test ! -x "$tool_specified"; then
14641             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
14642 $as_echo "not found" >&6; }
14643             as_fn_error $? "User supplied tool CPIO=$tool_specified does not exist or is not executable" "$LINENO" 5
14644           fi
14645           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
14646 $as_echo "$tool_specified" >&6; }
14647         fi
14648       fi
14649     fi
14650 
14651   fi
14652 
14653 
14654 
14655 
14656   # Publish this variable in the help.
14657 
14658 
14659   if [ -z "${NICE+x}" ]; then
14660     # The variable is not set by user, try to locate tool using the code snippet
14661     for ac_prog in nice
14662 do
14663   # Extract the first word of "$ac_prog", so it can be a program name with args.
14664 set dummy $ac_prog; ac_word=$2
14665 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14666 $as_echo_n "checking for $ac_word... " >&6; }
14667 if ${ac_cv_path_NICE+:} false; then :
14668   $as_echo_n "(cached) " >&6
14669 else
14670   case $NICE in
14671   [\\/]* | ?:[\\/]*)
14672   ac_cv_path_NICE="$NICE" # Let the user override the test with a path.
14673   ;;
14674   *)
14675   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14676 for as_dir in $PATH
14677 do
14678   IFS=$as_save_IFS
14679   test -z "$as_dir" && as_dir=.
14680     for ac_exec_ext in '' $ac_executable_extensions; do
14681   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14682     ac_cv_path_NICE="$as_dir/$ac_word$ac_exec_ext"
14683     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14684     break 2
14685   fi
14686 done
14687   done
14688 IFS=$as_save_IFS
14689 
14690   ;;
14691 esac
14692 fi
14693 NICE=$ac_cv_path_NICE
14694 if test -n "$NICE"; then
14695   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NICE" >&5
14696 $as_echo "$NICE" >&6; }
14697 else
14698   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14699 $as_echo "no" >&6; }
14700 fi
14701 
14702 
14703   test -n "$NICE" && break
14704 done
14705 
14706   else
14707     # The variable is set, but is it from the command line or the environment?
14708 
14709     # Try to remove the string !NICE! from our list.
14710     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!NICE!/}
14711     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
14712       # If it failed, the variable was not from the command line. Ignore it,
14713       # but warn the user (except for BASH, which is always set by the calling BASH).
14714       if test "xNICE" != xBASH; then
14715         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of NICE from the environment. Use command line variables instead." >&5
14716 $as_echo "$as_me: WARNING: Ignoring value of NICE from the environment. Use command line variables instead." >&2;}
14717       fi
14718       # Try to locate tool using the code snippet
14719       for ac_prog in nice
14720 do
14721   # Extract the first word of "$ac_prog", so it can be a program name with args.
14722 set dummy $ac_prog; ac_word=$2
14723 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14724 $as_echo_n "checking for $ac_word... " >&6; }
14725 if ${ac_cv_path_NICE+:} false; then :
14726   $as_echo_n "(cached) " >&6
14727 else
14728   case $NICE in
14729   [\\/]* | ?:[\\/]*)
14730   ac_cv_path_NICE="$NICE" # Let the user override the test with a path.
14731   ;;
14732   *)
14733   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14734 for as_dir in $PATH
14735 do
14736   IFS=$as_save_IFS
14737   test -z "$as_dir" && as_dir=.
14738     for ac_exec_ext in '' $ac_executable_extensions; do
14739   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14740     ac_cv_path_NICE="$as_dir/$ac_word$ac_exec_ext"
14741     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14742     break 2
14743   fi
14744 done
14745   done
14746 IFS=$as_save_IFS
14747 
14748   ;;
14749 esac
14750 fi
14751 NICE=$ac_cv_path_NICE
14752 if test -n "$NICE"; then
14753   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NICE" >&5
14754 $as_echo "$NICE" >&6; }
14755 else
14756   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14757 $as_echo "no" >&6; }
14758 fi
14759 
14760 
14761   test -n "$NICE" && break
14762 done
14763 
14764     else
14765       # If it succeeded, then it was overridden by the user. We will use it
14766       # for the tool.
14767 
14768       # First remove it from the list of overridden variables, so we can test
14769       # for unknown variables in the end.
14770       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
14771 
14772       # Check if we try to supply an empty value
14773       if test "x$NICE" = x; then
14774         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool NICE= (no value)" >&5
14775 $as_echo "$as_me: Setting user supplied tool NICE= (no value)" >&6;}
14776         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NICE" >&5
14777 $as_echo_n "checking for NICE... " >&6; }
14778         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
14779 $as_echo "disabled" >&6; }
14780       else
14781         # Check if the provided tool contains a complete path.
14782         tool_specified="$NICE"
14783         tool_basename="${tool_specified##*/}"
14784         if test "x$tool_basename" = "x$tool_specified"; then
14785           # A command without a complete path is provided, search $PATH.
14786           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool NICE=$tool_basename" >&5
14787 $as_echo "$as_me: Will search for user supplied tool NICE=$tool_basename" >&6;}
14788           # Extract the first word of "$tool_basename", so it can be a program name with args.
14789 set dummy $tool_basename; ac_word=$2
14790 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14791 $as_echo_n "checking for $ac_word... " >&6; }
14792 if ${ac_cv_path_NICE+:} false; then :
14793   $as_echo_n "(cached) " >&6
14794 else
14795   case $NICE in
14796   [\\/]* | ?:[\\/]*)
14797   ac_cv_path_NICE="$NICE" # Let the user override the test with a path.
14798   ;;
14799   *)
14800   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14801 for as_dir in $PATH
14802 do
14803   IFS=$as_save_IFS
14804   test -z "$as_dir" && as_dir=.
14805     for ac_exec_ext in '' $ac_executable_extensions; do
14806   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14807     ac_cv_path_NICE="$as_dir/$ac_word$ac_exec_ext"
14808     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14809     break 2
14810   fi
14811 done
14812   done
14813 IFS=$as_save_IFS
14814 
14815   ;;
14816 esac
14817 fi
14818 NICE=$ac_cv_path_NICE
14819 if test -n "$NICE"; then
14820   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NICE" >&5
14821 $as_echo "$NICE" >&6; }
14822 else
14823   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14824 $as_echo "no" >&6; }
14825 fi
14826 
14827 
14828           if test "x$NICE" = x; then
14829             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
14830           fi
14831         else
14832           # Otherwise we believe it is a complete path. Use it as it is.
14833           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool NICE=$tool_specified" >&5
14834 $as_echo "$as_me: Will use user supplied tool NICE=$tool_specified" >&6;}
14835           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NICE" >&5
14836 $as_echo_n "checking for NICE... " >&6; }
14837           if test ! -x "$tool_specified"; then
14838             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
14839 $as_echo "not found" >&6; }
14840             as_fn_error $? "User supplied tool NICE=$tool_specified does not exist or is not executable" "$LINENO" 5
14841           fi
14842           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
14843 $as_echo "$tool_specified" >&6; }
14844         fi
14845       fi
14846     fi
14847 
14848   fi
14849 
14850 
14851 
14852 
14853 # Now we can determine OpenJDK build and target platforms. This is required to
14854 # have early on.
14855 # Make sure we can run config.sub.
14856 $SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
14857   as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5
14858 
14859 { $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
14860 $as_echo_n "checking build system type... " >&6; }
14861 if ${ac_cv_build+:} false; then :
14862   $as_echo_n "(cached) " >&6
14863 else
14864   ac_build_alias=$build_alias
14865 test "x$ac_build_alias" = x &&
14866   ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
14867 test "x$ac_build_alias" = x &&
14868   as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5
14869 ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
14870   as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5
14871 
14872 fi
14873 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
14874 $as_echo "$ac_cv_build" >&6; }
14875 case $ac_cv_build in
14876 *-*-*) ;;
14877 *) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;;
14878 esac
14879 build=$ac_cv_build
14880 ac_save_IFS=$IFS; IFS='-'
14881 set x $ac_cv_build
14882 shift
14883 build_cpu=$1
14884 build_vendor=$2
14885 shift; shift
14886 # Remember, the first character of IFS is used to create $*,
14887 # except with old shells:
14888 build_os=$*
14889 IFS=$ac_save_IFS
14890 case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
14891 
14892 
14893 { $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
14894 $as_echo_n "checking host system type... " >&6; }
14895 if ${ac_cv_host+:} false; then :
14896   $as_echo_n "(cached) " >&6
14897 else
14898   if test "x$host_alias" = x; then
14899   ac_cv_host=$ac_cv_build
14900 else
14901   ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
14902     as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5
14903 fi
14904 
14905 fi
14906 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
14907 $as_echo "$ac_cv_host" >&6; }
14908 case $ac_cv_host in
14909 *-*-*) ;;
14910 *) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;;
14911 esac
14912 host=$ac_cv_host
14913 ac_save_IFS=$IFS; IFS='-'
14914 set x $ac_cv_host
14915 shift
14916 host_cpu=$1
14917 host_vendor=$2
14918 shift; shift
14919 # Remember, the first character of IFS is used to create $*,
14920 # except with old shells:
14921 host_os=$*
14922 IFS=$ac_save_IFS
14923 case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
14924 
14925 
14926 { $as_echo "$as_me:${as_lineno-$LINENO}: checking target system type" >&5
14927 $as_echo_n "checking target system type... " >&6; }
14928 if ${ac_cv_target+:} false; then :
14929   $as_echo_n "(cached) " >&6
14930 else
14931   if test "x$target_alias" = x; then
14932   ac_cv_target=$ac_cv_host
14933 else
14934   ac_cv_target=`$SHELL "$ac_aux_dir/config.sub" $target_alias` ||
14935     as_fn_error $? "$SHELL $ac_aux_dir/config.sub $target_alias failed" "$LINENO" 5
14936 fi
14937 
14938 fi
14939 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_target" >&5
14940 $as_echo "$ac_cv_target" >&6; }
14941 case $ac_cv_target in
14942 *-*-*) ;;
14943 *) as_fn_error $? "invalid value of canonical target" "$LINENO" 5;;
14944 esac
14945 target=$ac_cv_target
14946 ac_save_IFS=$IFS; IFS='-'
14947 set x $ac_cv_target
14948 shift
14949 target_cpu=$1
14950 target_vendor=$2
14951 shift; shift
14952 # Remember, the first character of IFS is used to create $*,
14953 # except with old shells:
14954 target_os=$*
14955 IFS=$ac_save_IFS
14956 case $target_os in *\ *) target_os=`echo "$target_os" | sed 's/ /-/g'`;; esac
14957 
14958 
14959 # The aliases save the names the user supplied, while $host etc.
14960 # will get canonicalized.
14961 test -n "$target_alias" &&
14962   test "$program_prefix$program_suffix$program_transform_name" = \
14963     NONENONEs,x,x, &&
14964   program_prefix=${target_alias}-
14965 
14966   # Figure out the build and target systems. # Note that in autoconf terminology, "build" is obvious, but "target"
14967   # is confusing; it assumes you are cross-compiling a cross-compiler (!)  and "target" is thus the target of the
14968   # product you're building. The target of this build is called "host". Since this is confusing to most people, we
14969   # have not adopted that system, but use "target" as the platform we are building for. In some places though we need
14970   # to use the configure naming style.
14971 
14972 
14973 
14974 
14975 
14976   # Copy the autoconf trip/quadruplet verbatim to OPENJDK_TARGET_AUTOCONF_NAME
14977   # (from the autoconf "host") and OPENJDK_BUILD_AUTOCONF_NAME
14978   # Note that we might later on rewrite e.g. OPENJDK_TARGET_CPU due to reduced build,
14979   # but this will not change the value of OPENJDK_TARGET_AUTOCONF_NAME.
14980   OPENJDK_TARGET_AUTOCONF_NAME="$host"
14981   OPENJDK_BUILD_AUTOCONF_NAME="$build"
14982 
14983 
14984 
14985   # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
14986 
14987   case "$build_os" in
14988     *linux*)
14989       VAR_OS=linux
14990       VAR_OS_TYPE=unix
14991       ;;
14992     *solaris*)
14993       VAR_OS=solaris
14994       VAR_OS_TYPE=unix
14995       ;;
14996     *darwin*)
14997       VAR_OS=macosx
14998       VAR_OS_TYPE=unix
14999       ;;
15000     *bsd*)
15001       VAR_OS=bsd
15002       VAR_OS_TYPE=unix
15003       ;;
15004     *cygwin*)
15005       VAR_OS=windows
15006       VAR_OS_ENV=windows.cygwin
15007       ;;
15008     *mingw*)
15009       VAR_OS=windows
15010       VAR_OS_ENV=windows.msys
15011       ;;
15012     *aix*)
15013       VAR_OS=aix
15014       VAR_OS_TYPE=unix
15015       ;;
15016     *)
15017       as_fn_error $? "unsupported operating system $build_os" "$LINENO" 5
15018       ;;
15019   esac
15020 
15021 
15022   # First argument is the cpu name from the trip/quad
15023   case "$build_cpu" in
15024     x86_64)
15025       VAR_CPU=x86_64
15026       VAR_CPU_ARCH=x86
15027       VAR_CPU_BITS=64
15028       VAR_CPU_ENDIAN=little
15029       ;;
15030     i?86)
15031       VAR_CPU=x86
15032       VAR_CPU_ARCH=x86
15033       VAR_CPU_BITS=32
15034       VAR_CPU_ENDIAN=little
15035       ;;
15036     arm*)
15037       VAR_CPU=arm
15038       VAR_CPU_ARCH=arm
15039       VAR_CPU_BITS=32
15040       VAR_CPU_ENDIAN=little
15041       ;;
15042     aarch64)
15043       VAR_CPU=aarch64
15044       VAR_CPU_ARCH=aarch64
15045       VAR_CPU_BITS=64
15046       VAR_CPU_ENDIAN=little
15047       ;;
15048     powerpc)
15049       VAR_CPU=ppc
15050       VAR_CPU_ARCH=ppc
15051       VAR_CPU_BITS=32
15052       VAR_CPU_ENDIAN=big
15053       ;;
15054     powerpc64)
15055       VAR_CPU=ppc64
15056       VAR_CPU_ARCH=ppc
15057       VAR_CPU_BITS=64
15058       VAR_CPU_ENDIAN=big
15059       ;;
15060     powerpc64le)
15061       VAR_CPU=ppc64le
15062       VAR_CPU_ARCH=ppc
15063       VAR_CPU_BITS=64
15064       VAR_CPU_ENDIAN=little
15065       ;;
15066     s390)
15067       VAR_CPU=s390
15068       VAR_CPU_ARCH=s390
15069       VAR_CPU_BITS=32
15070       VAR_CPU_ENDIAN=big
15071       ;;
15072     s390x)
15073       VAR_CPU=s390x
15074       VAR_CPU_ARCH=s390
15075       VAR_CPU_BITS=64
15076       VAR_CPU_ENDIAN=big
15077       ;;
15078     sparc)
15079       VAR_CPU=sparc
15080       VAR_CPU_ARCH=sparc
15081       VAR_CPU_BITS=32
15082       VAR_CPU_ENDIAN=big
15083       ;;
15084     sparcv9|sparc64)
15085       VAR_CPU=sparcv9
15086       VAR_CPU_ARCH=sparc
15087       VAR_CPU_BITS=64
15088       VAR_CPU_ENDIAN=big
15089       ;;
15090     *)
15091       as_fn_error $? "unsupported cpu $build_cpu" "$LINENO" 5
15092       ;;
15093   esac
15094 
15095   # ..and setup our own variables. (Do this explicitely to facilitate searching)
15096   OPENJDK_BUILD_OS="$VAR_OS"
15097   if test "x$VAR_OS_TYPE" != x; then
15098     OPENJDK_BUILD_OS_TYPE="$VAR_OS_TYPE"
15099   else
15100     OPENJDK_BUILD_OS_TYPE="$VAR_OS"
15101   fi
15102   if test "x$VAR_OS_ENV" != x; then
15103     OPENJDK_BUILD_OS_ENV="$VAR_OS_ENV"
15104   else
15105     OPENJDK_BUILD_OS_ENV="$VAR_OS"
15106   fi
15107   OPENJDK_BUILD_CPU="$VAR_CPU"
15108   OPENJDK_BUILD_CPU_ARCH="$VAR_CPU_ARCH"
15109   OPENJDK_BUILD_CPU_BITS="$VAR_CPU_BITS"
15110   OPENJDK_BUILD_CPU_ENDIAN="$VAR_CPU_ENDIAN"
15111 
15112 
15113 
15114 
15115 
15116 
15117 
15118 
15119   { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-build os-cpu" >&5
15120 $as_echo_n "checking openjdk-build os-cpu... " >&6; }
15121   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&5
15122 $as_echo "$OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&6; }
15123 
15124   # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
15125 
15126   case "$host_os" in
15127     *linux*)
15128       VAR_OS=linux
15129       VAR_OS_TYPE=unix
15130       ;;
15131     *solaris*)
15132       VAR_OS=solaris
15133       VAR_OS_TYPE=unix
15134       ;;
15135     *darwin*)
15136       VAR_OS=macosx
15137       VAR_OS_TYPE=unix
15138       ;;
15139     *bsd*)
15140       VAR_OS=bsd
15141       VAR_OS_TYPE=unix
15142       ;;
15143     *cygwin*)
15144       VAR_OS=windows
15145       VAR_OS_ENV=windows.cygwin
15146       ;;
15147     *mingw*)
15148       VAR_OS=windows
15149       VAR_OS_ENV=windows.msys
15150       ;;
15151     *aix*)
15152       VAR_OS=aix
15153       VAR_OS_TYPE=unix
15154       ;;
15155     *)
15156       as_fn_error $? "unsupported operating system $host_os" "$LINENO" 5
15157       ;;
15158   esac
15159 
15160 
15161   # First argument is the cpu name from the trip/quad
15162   case "$host_cpu" in
15163     x86_64)
15164       VAR_CPU=x86_64
15165       VAR_CPU_ARCH=x86
15166       VAR_CPU_BITS=64
15167       VAR_CPU_ENDIAN=little
15168       ;;
15169     i?86)
15170       VAR_CPU=x86
15171       VAR_CPU_ARCH=x86
15172       VAR_CPU_BITS=32
15173       VAR_CPU_ENDIAN=little
15174       ;;
15175     arm*)
15176       VAR_CPU=arm
15177       VAR_CPU_ARCH=arm
15178       VAR_CPU_BITS=32
15179       VAR_CPU_ENDIAN=little
15180       ;;
15181     aarch64)
15182       VAR_CPU=aarch64
15183       VAR_CPU_ARCH=aarch64
15184       VAR_CPU_BITS=64
15185       VAR_CPU_ENDIAN=little
15186       ;;
15187     powerpc)
15188       VAR_CPU=ppc
15189       VAR_CPU_ARCH=ppc
15190       VAR_CPU_BITS=32
15191       VAR_CPU_ENDIAN=big
15192       ;;
15193     powerpc64)
15194       VAR_CPU=ppc64
15195       VAR_CPU_ARCH=ppc
15196       VAR_CPU_BITS=64
15197       VAR_CPU_ENDIAN=big
15198       ;;
15199     powerpc64le)
15200       VAR_CPU=ppc64le
15201       VAR_CPU_ARCH=ppc
15202       VAR_CPU_BITS=64
15203       VAR_CPU_ENDIAN=little
15204       ;;
15205     s390)
15206       VAR_CPU=s390
15207       VAR_CPU_ARCH=s390
15208       VAR_CPU_BITS=32
15209       VAR_CPU_ENDIAN=big
15210       ;;
15211     s390x)
15212       VAR_CPU=s390x
15213       VAR_CPU_ARCH=s390
15214       VAR_CPU_BITS=64
15215       VAR_CPU_ENDIAN=big
15216       ;;
15217     sparc)
15218       VAR_CPU=sparc
15219       VAR_CPU_ARCH=sparc
15220       VAR_CPU_BITS=32
15221       VAR_CPU_ENDIAN=big
15222       ;;
15223     sparcv9|sparc64)
15224       VAR_CPU=sparcv9
15225       VAR_CPU_ARCH=sparc
15226       VAR_CPU_BITS=64
15227       VAR_CPU_ENDIAN=big
15228       ;;
15229     *)
15230       as_fn_error $? "unsupported cpu $host_cpu" "$LINENO" 5
15231       ;;
15232   esac
15233 
15234   # ... and setup our own variables. (Do this explicitely to facilitate searching)
15235   OPENJDK_TARGET_OS="$VAR_OS"
15236   if test "x$VAR_OS_TYPE" != x; then
15237     OPENJDK_TARGET_OS_TYPE="$VAR_OS_TYPE"
15238   else
15239     OPENJDK_TARGET_OS_TYPE="$VAR_OS"
15240   fi
15241   if test "x$VAR_OS_ENV" != x; then
15242     OPENJDK_TARGET_OS_ENV="$VAR_OS_ENV"
15243   else
15244     OPENJDK_TARGET_OS_ENV="$VAR_OS"
15245   fi
15246   OPENJDK_TARGET_CPU="$VAR_CPU"
15247   OPENJDK_TARGET_CPU_ARCH="$VAR_CPU_ARCH"
15248   OPENJDK_TARGET_CPU_BITS="$VAR_CPU_BITS"
15249   OPENJDK_TARGET_CPU_ENDIAN="$VAR_CPU_ENDIAN"
15250 
15251 
15252 
15253 
15254 
15255 
15256 
15257 
15258   { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-target os-cpu" >&5
15259 $as_echo_n "checking openjdk-target os-cpu... " >&6; }
15260   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&5
15261 $as_echo "$OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&6; }
15262 
15263 
15264 
15265 # Check whether --with-target-bits was given.
15266 if test "${with_target_bits+set}" = set; then :
15267   withval=$with_target_bits;
15268 fi
15269 
15270 
15271   # We have three types of compiles:
15272   # native  == normal compilation, target system == build system
15273   # cross   == traditional cross compilation, target system != build system; special toolchain needed
15274   # reduced == using native compilers, but with special flags (e.g. -m32) to produce 32-bit builds on 64-bit machines
15275   #
15276   if test "x$OPENJDK_BUILD_AUTOCONF_NAME" != "x$OPENJDK_TARGET_AUTOCONF_NAME"; then
15277     # We're doing a proper cross-compilation
15278     COMPILE_TYPE="cross"
15279   else
15280     COMPILE_TYPE="native"
15281   fi
15282 
15283   if test "x$with_target_bits" != x; then
15284     if test "x$COMPILE_TYPE" = "xcross"; then
15285       as_fn_error $? "It is not possible to combine --with-target-bits=X and proper cross-compilation. Choose either." "$LINENO" 5
15286     fi
15287 
15288     if test "x$with_target_bits" = x32 && test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
15289       # A reduced build is requested
15290       COMPILE_TYPE="reduced"
15291       OPENJDK_TARGET_CPU_BITS=32
15292       if test "x$OPENJDK_TARGET_CPU_ARCH" = "xx86"; then
15293         OPENJDK_TARGET_CPU=x86
15294       elif test "x$OPENJDK_TARGET_CPU_ARCH" = "xsparc"; then
15295         OPENJDK_TARGET_CPU=sparc
15296       else
15297         as_fn_error $? "Reduced build (--with-target-bits=32) is only supported on x86_64 and sparcv9" "$LINENO" 5
15298       fi
15299     elif test "x$with_target_bits" = x64 && test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
15300       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
15301     elif test "x$with_target_bits" = "x$OPENJDK_TARGET_CPU_BITS"; then
15302       { $as_echo "$as_me:${as_lineno-$LINENO}: --with-target-bits are set to build platform address size; argument has no meaning" >&5
15303 $as_echo "$as_me: --with-target-bits are set to build platform address size; argument has no meaning" >&6;}
15304     else
15305       as_fn_error $? "--with-target-bits can only be 32 or 64, you specified $with_target_bits!" "$LINENO" 5
15306     fi
15307   fi
15308 
15309 
15310   { $as_echo "$as_me:${as_lineno-$LINENO}: checking compilation type" >&5
15311 $as_echo_n "checking compilation type... " >&6; }
15312   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMPILE_TYPE" >&5
15313 $as_echo "$COMPILE_TYPE" >&6; }
15314 
15315 
15316   if test "x$OPENJDK_TARGET_OS" = "xsolaris"; then
15317     REQUIRED_OS_NAME=SunOS
15318     REQUIRED_OS_VERSION=5.10
15319   fi
15320   if test "x$OPENJDK_TARGET_OS" = "xlinux"; then
15321     REQUIRED_OS_NAME=Linux
15322     REQUIRED_OS_VERSION=2.6
15323   fi
15324   if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
15325     REQUIRED_OS_NAME=Windows
15326     if test "x$OPENJDK_TARGET_CPU_BITS" = "x64"; then
15327       REQUIRED_OS_VERSION=5.2
15328     else
15329       REQUIRED_OS_VERSION=5.1
15330     fi
15331   fi
15332   if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
15333     REQUIRED_OS_NAME=Darwin
15334     REQUIRED_OS_VERSION=11.2
15335   fi
15336   if test "x$OPENJDK_TARGET_OS" = "xaix"; then
15337     REQUIRED_OS_NAME=AIX
15338     REQUIRED_OS_VERSION=7.1
15339   fi
15340 
15341 
15342 
15343 
15344 
15345 
15346   # Also store the legacy naming of the cpu.
15347   # Ie i586 and amd64 instead of x86 and x86_64
15348   OPENJDK_TARGET_CPU_LEGACY="$OPENJDK_TARGET_CPU"
15349   if test "x$OPENJDK_TARGET_CPU" = xx86; then
15350     OPENJDK_TARGET_CPU_LEGACY="i586"
15351   elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
15352     # On all platforms except MacOSX replace x86_64 with amd64.
15353     OPENJDK_TARGET_CPU_LEGACY="amd64"
15354   fi
15355 
15356 
15357   # And the second legacy naming of the cpu.
15358   # Ie i386 and amd64 instead of x86 and x86_64.
15359   OPENJDK_TARGET_CPU_LEGACY_LIB="$OPENJDK_TARGET_CPU"
15360   if test "x$OPENJDK_TARGET_CPU" = xx86; then
15361     OPENJDK_TARGET_CPU_LEGACY_LIB="i386"
15362   elif test "x$OPENJDK_TARGET_CPU" = xx86_64; then
15363     OPENJDK_TARGET_CPU_LEGACY_LIB="amd64"
15364   fi
15365 
15366 
15367   # This is the name of the cpu (but using i386 and amd64 instead of
15368   # x86 and x86_64, respectively), preceeded by a /, to be used when
15369   # locating libraries. On macosx, it's empty, though.
15370   OPENJDK_TARGET_CPU_LIBDIR="/$OPENJDK_TARGET_CPU_LEGACY_LIB"
15371   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
15372     OPENJDK_TARGET_CPU_LIBDIR=""
15373   fi
15374 
15375 
15376   # OPENJDK_TARGET_CPU_ISADIR is normally empty. On 64-bit Solaris systems, it is set to
15377   # /amd64 or /sparcv9. This string is appended to some library paths, like this:
15378   # /usr/lib${OPENJDK_TARGET_CPU_ISADIR}/libexample.so
15379   OPENJDK_TARGET_CPU_ISADIR=""
15380   if test "x$OPENJDK_TARGET_OS" = xsolaris; then
15381     if test "x$OPENJDK_TARGET_CPU" = xx86_64; then
15382       OPENJDK_TARGET_CPU_ISADIR="/amd64"
15383     elif test "x$OPENJDK_TARGET_CPU" = xsparcv9; then
15384       OPENJDK_TARGET_CPU_ISADIR="/sparcv9"
15385     fi
15386   fi
15387 
15388 
15389   # Setup OPENJDK_TARGET_CPU_OSARCH, which is used to set the os.arch Java system property
15390   OPENJDK_TARGET_CPU_OSARCH="$OPENJDK_TARGET_CPU"
15391   if test "x$OPENJDK_TARGET_OS" = xlinux && test "x$OPENJDK_TARGET_CPU" = xx86; then
15392     # On linux only, we replace x86 with i386.
15393     OPENJDK_TARGET_CPU_OSARCH="i386"
15394   elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
15395     # On all platforms except macosx, we replace x86_64 with amd64.
15396     OPENJDK_TARGET_CPU_OSARCH="amd64"
15397   fi
15398 
15399 
15400   OPENJDK_TARGET_CPU_JLI="$OPENJDK_TARGET_CPU"
15401   if test "x$OPENJDK_TARGET_CPU" = xx86; then
15402     OPENJDK_TARGET_CPU_JLI="i386"
15403   elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
15404     # On all platforms except macosx, we replace x86_64 with amd64.
15405     OPENJDK_TARGET_CPU_JLI="amd64"
15406   fi
15407   # Now setup the -D flags for building libjli.
15408   OPENJDK_TARGET_CPU_JLI_CFLAGS="-DLIBARCHNAME='\"$OPENJDK_TARGET_CPU_JLI\"'"
15409   if test "x$OPENJDK_TARGET_OS" = xsolaris; then
15410     if test "x$OPENJDK_TARGET_CPU_ARCH" = xsparc; then
15411       OPENJDK_TARGET_CPU_JLI_CFLAGS="$OPENJDK_TARGET_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"sparc\"' -DLIBARCH64NAME='\"sparcv9\"'"
15412     elif test "x$OPENJDK_TARGET_CPU_ARCH" = xx86; then
15413       OPENJDK_TARGET_CPU_JLI_CFLAGS="$OPENJDK_TARGET_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"i386\"' -DLIBARCH64NAME='\"amd64\"'"
15414     fi
15415   fi
15416 
15417 
15418   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
15419       OPENJDK_TARGET_OS_EXPORT_DIR=macosx
15420   else
15421       OPENJDK_TARGET_OS_EXPORT_DIR=${OPENJDK_TARGET_OS_TYPE}
15422   fi
15423 
15424 
15425   if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
15426     A_LP64="LP64:="
15427     # -D_LP64=1 is only set on linux and mac. Setting on windows causes diff in
15428     # unpack200.exe
15429     if test "x$OPENJDK_TARGET_OS" = xlinux || test "x$OPENJDK_TARGET_OS" = xmacosx; then
15430       OPENJDK_TARGET_ADD_LP64="-D_LP64=1"
15431     fi
15432   fi
15433   LP64=$A_LP64
15434 
15435 
15436   if test "x$COMPILE_TYPE" = "xcross"; then
15437     # FIXME: ... or should this include reduced builds..?
15438     DEFINE_CROSS_COMPILE_ARCH="CROSS_COMPILE_ARCH:=$OPENJDK_TARGET_CPU_LEGACY"
15439   else
15440     DEFINE_CROSS_COMPILE_ARCH=""
15441   fi
15442 
15443 
15444   # Convert openjdk platform names to hotspot names
15445 
15446   HOTSPOT_TARGET_OS=${OPENJDK_TARGET_OS}
15447   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
15448     HOTSPOT_TARGET_OS=bsd
15449   fi
15450 
15451 
15452   HOTSPOT_TARGET_OS_TYPE=${OPENJDK_TARGET_OS_TYPE}
15453   if test "x$OPENJDK_TARGET_OS_TYPE" = xunix; then
15454     HOTSPOT_TARGET_OS_TYPE=posix
15455   fi
15456 
15457 
15458   HOTSPOT_TARGET_CPU=${OPENJDK_TARGET_CPU}
15459   if test "x$OPENJDK_TARGET_CPU" = xx86; then
15460     HOTSPOT_TARGET_CPU=x86_32
15461   elif test "x$OPENJDK_TARGET_CPU" = xsparcv9; then
15462     HOTSPOT_TARGET_CPU=sparc
15463   elif test "x$OPENJDK_TARGET_CPU" = xppc64; then
15464     HOTSPOT_TARGET_CPU=ppc_64
15465   elif test "x$OPENJDK_TARGET_CPU" = xppc64le; then
15466     HOTSPOT_TARGET_CPU=ppc_64
15467   fi
15468 
15469 
15470   # This is identical with OPENJDK_*, but define anyway for consistency.
15471   HOTSPOT_TARGET_CPU_ARCH=${OPENJDK_TARGET_CPU_ARCH}
15472 
15473 
15474   # Setup HOTSPOT_TARGET_CPU_DEFINE
15475   if test "x$OPENJDK_TARGET_CPU" = xx86; then
15476     HOTSPOT_TARGET_CPU_DEFINE=IA32
15477   elif test "x$OPENJDK_TARGET_CPU" = xx86_64; then
15478     HOTSPOT_TARGET_CPU_DEFINE=AMD64
15479   elif test "x$OPENJDK_TARGET_CPU" = xsparcv9; then
15480     HOTSPOT_TARGET_CPU_DEFINE=SPARC
15481   elif test "x$OPENJDK_TARGET_CPU" = xaarch64; then
15482     HOTSPOT_TARGET_CPU_DEFINE=AARCH64
15483   elif test "x$OPENJDK_TARGET_CPU" = xppc64; then
15484     HOTSPOT_TARGET_CPU_DEFINE=PPC64
15485   elif test "x$OPENJDK_TARGET_CPU" = xppc64le; then
15486     HOTSPOT_TARGET_CPU_DEFINE=PPC64
15487 
15488   # The cpu defines below are for zero, we don't support them directly.
15489   elif test "x$OPENJDK_TARGET_CPU" = xsparc; then
15490     HOTSPOT_TARGET_CPU_DEFINE=SPARC
15491   elif test "x$OPENJDK_TARGET_CPU" = xppc; then
15492     HOTSPOT_TARGET_CPU_DEFINE=PPC32
15493   elif test "x$OPENJDK_TARGET_CPU" = xs390; then
15494     HOTSPOT_TARGET_CPU_DEFINE=S390
15495   elif test "x$OPENJDK_TARGET_CPU" = ss390x; then
15496     HOTSPOT_TARGET_CPU_DEFINE=S390
15497   fi
15498 
15499 
15500 
15501 
15502   # Also store the legacy naming of the cpu.
15503   # Ie i586 and amd64 instead of x86 and x86_64
15504   OPENJDK_BUILD_CPU_LEGACY="$OPENJDK_BUILD_CPU"
15505   if test "x$OPENJDK_BUILD_CPU" = xx86; then
15506     OPENJDK_BUILD_CPU_LEGACY="i586"
15507   elif test "x$OPENJDK_BUILD_OS" != xmacosx && test "x$OPENJDK_BUILD_CPU" = xx86_64; then
15508     # On all platforms except MacOSX replace x86_64 with amd64.
15509     OPENJDK_BUILD_CPU_LEGACY="amd64"
15510   fi
15511 
15512 
15513   # And the second legacy naming of the cpu.
15514   # Ie i386 and amd64 instead of x86 and x86_64.
15515   OPENJDK_BUILD_CPU_LEGACY_LIB="$OPENJDK_BUILD_CPU"
15516   if test "x$OPENJDK_BUILD_CPU" = xx86; then
15517     OPENJDK_BUILD_CPU_LEGACY_LIB="i386"
15518   elif test "x$OPENJDK_BUILD_CPU" = xx86_64; then
15519     OPENJDK_BUILD_CPU_LEGACY_LIB="amd64"
15520   fi
15521 
15522 
15523   # This is the name of the cpu (but using i386 and amd64 instead of
15524   # x86 and x86_64, respectively), preceeded by a /, to be used when
15525   # locating libraries. On macosx, it's empty, though.
15526   OPENJDK_BUILD_CPU_LIBDIR="/$OPENJDK_BUILD_CPU_LEGACY_LIB"
15527   if test "x$OPENJDK_BUILD_OS" = xmacosx; then
15528     OPENJDK_BUILD_CPU_LIBDIR=""
15529   fi
15530 
15531 
15532   # OPENJDK_BUILD_CPU_ISADIR is normally empty. On 64-bit Solaris systems, it is set to
15533   # /amd64 or /sparcv9. This string is appended to some library paths, like this:
15534   # /usr/lib${OPENJDK_BUILD_CPU_ISADIR}/libexample.so
15535   OPENJDK_BUILD_CPU_ISADIR=""
15536   if test "x$OPENJDK_BUILD_OS" = xsolaris; then
15537     if test "x$OPENJDK_BUILD_CPU" = xx86_64; then
15538       OPENJDK_BUILD_CPU_ISADIR="/amd64"
15539     elif test "x$OPENJDK_BUILD_CPU" = xsparcv9; then
15540       OPENJDK_BUILD_CPU_ISADIR="/sparcv9"
15541     fi
15542   fi
15543 
15544 
15545   # Setup OPENJDK_BUILD_CPU_OSARCH, which is used to set the os.arch Java system property
15546   OPENJDK_BUILD_CPU_OSARCH="$OPENJDK_BUILD_CPU"
15547   if test "x$OPENJDK_BUILD_OS" = xlinux && test "x$OPENJDK_BUILD_CPU" = xx86; then
15548     # On linux only, we replace x86 with i386.
15549     OPENJDK_BUILD_CPU_OSARCH="i386"
15550   elif test "x$OPENJDK_BUILD_OS" != xmacosx && test "x$OPENJDK_BUILD_CPU" = xx86_64; then
15551     # On all platforms except macosx, we replace x86_64 with amd64.
15552     OPENJDK_BUILD_CPU_OSARCH="amd64"
15553   fi
15554 
15555 
15556   OPENJDK_BUILD_CPU_JLI="$OPENJDK_BUILD_CPU"
15557   if test "x$OPENJDK_BUILD_CPU" = xx86; then
15558     OPENJDK_BUILD_CPU_JLI="i386"
15559   elif test "x$OPENJDK_BUILD_OS" != xmacosx && test "x$OPENJDK_BUILD_CPU" = xx86_64; then
15560     # On all platforms except macosx, we replace x86_64 with amd64.
15561     OPENJDK_BUILD_CPU_JLI="amd64"
15562   fi
15563   # Now setup the -D flags for building libjli.
15564   OPENJDK_BUILD_CPU_JLI_CFLAGS="-DLIBARCHNAME='\"$OPENJDK_BUILD_CPU_JLI\"'"
15565   if test "x$OPENJDK_BUILD_OS" = xsolaris; then
15566     if test "x$OPENJDK_BUILD_CPU_ARCH" = xsparc; then
15567       OPENJDK_BUILD_CPU_JLI_CFLAGS="$OPENJDK_BUILD_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"sparc\"' -DLIBARCH64NAME='\"sparcv9\"'"
15568     elif test "x$OPENJDK_BUILD_CPU_ARCH" = xx86; then
15569       OPENJDK_BUILD_CPU_JLI_CFLAGS="$OPENJDK_BUILD_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"i386\"' -DLIBARCH64NAME='\"amd64\"'"
15570     fi
15571   fi
15572 
15573 
15574   if test "x$OPENJDK_BUILD_OS" = xmacosx; then
15575       OPENJDK_BUILD_OS_EXPORT_DIR=macosx
15576   else
15577       OPENJDK_BUILD_OS_EXPORT_DIR=${OPENJDK_BUILD_OS_TYPE}
15578   fi
15579 
15580 
15581   if test "x$OPENJDK_BUILD_CPU_BITS" = x64; then
15582     A_LP64="LP64:="
15583     # -D_LP64=1 is only set on linux and mac. Setting on windows causes diff in
15584     # unpack200.exe
15585     if test "x$OPENJDK_BUILD_OS" = xlinux || test "x$OPENJDK_BUILD_OS" = xmacosx; then
15586       OPENJDK_BUILD_ADD_LP64="-D_LP64=1"
15587     fi
15588   fi
15589   LP64=$A_LP64
15590 
15591 
15592   if test "x$COMPILE_TYPE" = "xcross"; then
15593     # FIXME: ... or should this include reduced builds..?
15594     DEFINE_CROSS_COMPILE_ARCH="CROSS_COMPILE_ARCH:=$OPENJDK_BUILD_CPU_LEGACY"
15595   else
15596     DEFINE_CROSS_COMPILE_ARCH=""
15597   fi
15598 
15599 
15600   # Convert openjdk platform names to hotspot names
15601 
15602   HOTSPOT_BUILD_OS=${OPENJDK_BUILD_OS}
15603   if test "x$OPENJDK_BUILD_OS" = xmacosx; then
15604     HOTSPOT_BUILD_OS=bsd
15605   fi
15606 
15607 
15608   HOTSPOT_BUILD_OS_TYPE=${OPENJDK_BUILD_OS_TYPE}
15609   if test "x$OPENJDK_BUILD_OS_TYPE" = xunix; then
15610     HOTSPOT_BUILD_OS_TYPE=posix
15611   fi
15612 
15613 
15614   HOTSPOT_BUILD_CPU=${OPENJDK_BUILD_CPU}
15615   if test "x$OPENJDK_BUILD_CPU" = xx86; then
15616     HOTSPOT_BUILD_CPU=x86_32
15617   elif test "x$OPENJDK_BUILD_CPU" = xsparcv9; then
15618     HOTSPOT_BUILD_CPU=sparc
15619   elif test "x$OPENJDK_BUILD_CPU" = xppc64; then
15620     HOTSPOT_BUILD_CPU=ppc_64
15621   elif test "x$OPENJDK_BUILD_CPU" = xppc64le; then
15622     HOTSPOT_BUILD_CPU=ppc_64
15623   fi
15624 
15625 
15626   # This is identical with OPENJDK_*, but define anyway for consistency.
15627   HOTSPOT_BUILD_CPU_ARCH=${OPENJDK_BUILD_CPU_ARCH}
15628 
15629 
15630   # Setup HOTSPOT_BUILD_CPU_DEFINE
15631   if test "x$OPENJDK_BUILD_CPU" = xx86; then
15632     HOTSPOT_BUILD_CPU_DEFINE=IA32
15633   elif test "x$OPENJDK_BUILD_CPU" = xx86_64; then
15634     HOTSPOT_BUILD_CPU_DEFINE=AMD64
15635   elif test "x$OPENJDK_BUILD_CPU" = xsparcv9; then
15636     HOTSPOT_BUILD_CPU_DEFINE=SPARC
15637   elif test "x$OPENJDK_BUILD_CPU" = xaarch64; then
15638     HOTSPOT_BUILD_CPU_DEFINE=AARCH64
15639   elif test "x$OPENJDK_BUILD_CPU" = xppc64; then
15640     HOTSPOT_BUILD_CPU_DEFINE=PPC64
15641   elif test "x$OPENJDK_BUILD_CPU" = xppc64le; then
15642     HOTSPOT_BUILD_CPU_DEFINE=PPC64
15643 
15644   # The cpu defines below are for zero, we don't support them directly.
15645   elif test "x$OPENJDK_BUILD_CPU" = xsparc; then
15646     HOTSPOT_BUILD_CPU_DEFINE=SPARC
15647   elif test "x$OPENJDK_BUILD_CPU" = xppc; then
15648     HOTSPOT_BUILD_CPU_DEFINE=PPC32
15649   elif test "x$OPENJDK_BUILD_CPU" = xs390; then
15650     HOTSPOT_BUILD_CPU_DEFINE=S390
15651   elif test "x$OPENJDK_BUILD_CPU" = ss390x; then
15652     HOTSPOT_BUILD_CPU_DEFINE=S390
15653   fi
15654 
15655 
15656 
15657 
15658   # ZERO_ARCHDEF is used to enable architecture-specific code.
15659   # This is used in legacy hotspot build.
15660   ZERO_ARCHDEF="$HOTSPOT_TARGET_CPU_DEFINE"
15661 
15662 
15663 
15664 
15665 
15666 # Continue setting up basic stuff. Most remaining code require fundamental tools.
15667 
15668   # Save the current directory this script was started from
15669   CURDIR="$PWD"
15670 
15671   # We might need to rewrite ORIGINAL_PATH, if it includes "#", to quote them
15672   # for make. We couldn't do this when we retrieved ORIGINAL_PATH, since SED
15673   # was not available at that time.
15674   REWRITTEN_PATH=`$ECHO "$ORIGINAL_PATH" | $SED -e 's/#/\\\\#/g'`
15675   if test "x$REWRITTEN_PATH" != "x$ORIGINAL_PATH"; then
15676     ORIGINAL_PATH="$REWRITTEN_PATH"
15677     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting ORIGINAL_PATH to $REWRITTEN_PATH" >&5
15678 $as_echo "$as_me: Rewriting ORIGINAL_PATH to $REWRITTEN_PATH" >&6;}
15679   fi
15680 
15681   if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
15682     PATH_SEP=";"
15683 
15684   SRC_ROOT_LENGTH=`$THEPWDCMD -L|$WC -m`
15685   if test $SRC_ROOT_LENGTH -gt 100; then
15686     as_fn_error $? "Your base path is too long. It is $SRC_ROOT_LENGTH characters long, but only 100 is supported" "$LINENO" 5
15687   fi
15688 
15689   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15690     { $as_echo "$as_me:${as_lineno-$LINENO}: checking cygwin release" >&5
15691 $as_echo_n "checking cygwin release... " >&6; }
15692     CYGWIN_VERSION=`$UNAME -r`
15693     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_VERSION" >&5
15694 $as_echo "$CYGWIN_VERSION" >&6; }
15695     WINDOWS_ENV_VENDOR='cygwin'
15696     WINDOWS_ENV_VERSION="$CYGWIN_VERSION"
15697 
15698     CYGWIN_VERSION_OLD=`$ECHO $CYGWIN_VERSION | $GREP -e '^1\.0-6'`
15699     if test "x$CYGWIN_VERSION_OLD" != x; then
15700       { $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
15701 $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;}
15702       as_fn_error $? "Cannot continue" "$LINENO" 5
15703     fi
15704     if test "x$CYGPATH" = x; then
15705       as_fn_error $? "Something is wrong with your cygwin installation since I cannot find cygpath.exe in your path" "$LINENO" 5
15706     fi
15707     { $as_echo "$as_me:${as_lineno-$LINENO}: checking cygwin root directory as unix-style path" >&5
15708 $as_echo_n "checking cygwin root directory as unix-style path... " >&6; }
15709     # The cmd output ends with Windows line endings (CR/LF), the grep command will strip that away
15710     cygwin_winpath_root=`cd / ; cmd /c cd | grep ".*"`
15711     # Force cygpath to report the proper root by including a trailing space, and then stripping it off again.
15712     CYGWIN_ROOT_PATH=`$CYGPATH -u "$cygwin_winpath_root " | $CUT -f 1 -d " "`
15713     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_ROOT_PATH" >&5
15714 $as_echo "$CYGWIN_ROOT_PATH" >&6; }
15715     WINDOWS_ENV_ROOT_PATH="$CYGWIN_ROOT_PATH"
15716     test_cygdrive_prefix=`$ECHO $CYGWIN_ROOT_PATH | $GREP ^/cygdrive/`
15717     if test "x$test_cygdrive_prefix" = x; then
15718       as_fn_error $? "Your cygdrive prefix is not /cygdrive. This is currently not supported. Change with mount -c." "$LINENO" 5
15719     fi
15720   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15721     { $as_echo "$as_me:${as_lineno-$LINENO}: checking msys release" >&5
15722 $as_echo_n "checking msys release... " >&6; }
15723     MSYS_VERSION=`$UNAME -r`
15724     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSYS_VERSION" >&5
15725 $as_echo "$MSYS_VERSION" >&6; }
15726 
15727     WINDOWS_ENV_VENDOR='msys'
15728     WINDOWS_ENV_VERSION="$MSYS_VERSION"
15729 
15730     { $as_echo "$as_me:${as_lineno-$LINENO}: checking msys root directory as unix-style path" >&5
15731 $as_echo_n "checking msys root directory as unix-style path... " >&6; }
15732     # The cmd output ends with Windows line endings (CR/LF), the grep command will strip that away
15733     MSYS_ROOT_PATH=`cd / ; cmd /c cd | grep ".*"`
15734 
15735   windows_path="$MSYS_ROOT_PATH"
15736   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15737     unix_path=`$CYGPATH -u "$windows_path"`
15738     MSYS_ROOT_PATH="$unix_path"
15739   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15740     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15741     MSYS_ROOT_PATH="$unix_path"
15742   fi
15743 
15744     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSYS_ROOT_PATH" >&5
15745 $as_echo "$MSYS_ROOT_PATH" >&6; }
15746     WINDOWS_ENV_ROOT_PATH="$MSYS_ROOT_PATH"
15747   else
15748     as_fn_error $? "Unknown Windows environment. Neither cygwin nor msys was detected." "$LINENO" 5
15749   fi
15750 
15751   # Test if windows or unix (cygwin/msys) find is first in path.
15752   { $as_echo "$as_me:${as_lineno-$LINENO}: checking what kind of 'find' is first on the PATH" >&5
15753 $as_echo_n "checking what kind of 'find' is first on the PATH... " >&6; }
15754   FIND_BINARY_OUTPUT=`find --version 2>&1`
15755   if test "x`echo $FIND_BINARY_OUTPUT | $GREP GNU`" != x; then
15756     { $as_echo "$as_me:${as_lineno-$LINENO}: result: unix style" >&5
15757 $as_echo "unix style" >&6; }
15758   elif test "x`echo $FIND_BINARY_OUTPUT | $GREP FIND`" != x; then
15759     { $as_echo "$as_me:${as_lineno-$LINENO}: result: Windows" >&5
15760 $as_echo "Windows" >&6; }
15761     { $as_echo "$as_me:${as_lineno-$LINENO}: Your path contains Windows tools (C:\Windows\system32) before your unix (cygwin or msys) tools." >&5
15762 $as_echo "$as_me: Your path contains Windows tools (C:\Windows\system32) before your unix (cygwin or msys) tools." >&6;}
15763     { $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
15764 $as_echo "$as_me: This will not work. Please correct and make sure /usr/bin (or similar) is first in path." >&6;}
15765     as_fn_error $? "Cannot continue" "$LINENO" 5
15766   else
15767     { $as_echo "$as_me:${as_lineno-$LINENO}: result: unknown" >&5
15768 $as_echo "unknown" >&6; }
15769     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: It seems that your find utility is non-standard." >&5
15770 $as_echo "$as_me: WARNING: It seems that your find utility is non-standard." >&2;}
15771   fi
15772 
15773   else
15774     PATH_SEP=":"
15775   fi
15776 
15777 
15778   # We get the top-level directory from the supporting wrappers.
15779   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for top-level directory" >&5
15780 $as_echo_n "checking for top-level directory... " >&6; }
15781   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOPDIR" >&5
15782 $as_echo "$TOPDIR" >&6; }
15783 
15784 
15785   # Save the original version of TOPDIR for string comparisons
15786   ORIGINAL_TOPDIR="$TOPDIR"
15787 
15788 
15789   # We can only call BASIC_FIXUP_PATH after BASIC_CHECK_PATHS_WINDOWS.
15790 
15791   # Only process if variable expands to non-empty
15792 
15793   if test "x$CURDIR" != x; then
15794     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15795 
15796   # Input might be given as Windows format, start by converting to
15797   # unix format.
15798   path="$CURDIR"
15799   new_path=`$CYGPATH -u "$path"`
15800 
15801   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
15802   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
15803   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
15804   # "foo.exe" is OK but "foo" is an error.
15805   #
15806   # This test is therefore slightly more accurate than "test -f" to check for file precense.
15807   # It is also a way to make sure we got the proper file name for the real test later on.
15808   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
15809   if test "x$test_shortpath" = x; then
15810     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CURDIR, which resolves as \"$path\", is invalid." >&5
15811 $as_echo "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid." >&6;}
15812     as_fn_error $? "Cannot locate the the path of CURDIR" "$LINENO" 5
15813   fi
15814 
15815   # Call helper function which possibly converts this using DOS-style short mode.
15816   # If so, the updated path is stored in $new_path.
15817 
15818   input_path="$new_path"
15819   # Check if we need to convert this using DOS-style short mode. If the path
15820   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15821   # take no chances and rewrite it.
15822   # Note: m4 eats our [], so we need to use [ and ] instead.
15823   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
15824   if test "x$has_forbidden_chars" != x; then
15825     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15826     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
15827     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
15828     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
15829       # Going to short mode and back again did indeed matter. Since short mode is
15830       # case insensitive, let's make it lowercase to improve readability.
15831       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15832       # Now convert it back to Unix-style (cygpath)
15833       input_path=`$CYGPATH -u "$shortmode_path"`
15834       new_path="$input_path"
15835     fi
15836   fi
15837 
15838   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
15839   if test "x$test_cygdrive_prefix" = x; then
15840     # As a simple fix, exclude /usr/bin since it's not a real path.
15841     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
15842       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
15843       # a path prefixed by /cygdrive for fixpath to work.
15844       new_path="$CYGWIN_ROOT_PATH$input_path"
15845     fi
15846   fi
15847 
15848 
15849   if test "x$path" != "x$new_path"; then
15850     CURDIR="$new_path"
15851     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
15852 $as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
15853   fi
15854 
15855     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15856 
15857   path="$CURDIR"
15858   has_colon=`$ECHO $path | $GREP ^.:`
15859   new_path="$path"
15860   if test "x$has_colon" = x; then
15861     # Not in mixed or Windows style, start by that.
15862     new_path=`cmd //c echo $path`
15863   fi
15864 
15865 
15866   input_path="$new_path"
15867   # Check if we need to convert this using DOS-style short mode. If the path
15868   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15869   # take no chances and rewrite it.
15870   # Note: m4 eats our [], so we need to use [ and ] instead.
15871   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
15872   if test "x$has_forbidden_chars" != x; then
15873     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15874     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15875   fi
15876 
15877 
15878   windows_path="$new_path"
15879   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15880     unix_path=`$CYGPATH -u "$windows_path"`
15881     new_path="$unix_path"
15882   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15883     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15884     new_path="$unix_path"
15885   fi
15886 
15887   if test "x$path" != "x$new_path"; then
15888     CURDIR="$new_path"
15889     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
15890 $as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
15891   fi
15892 
15893   # Save the first 10 bytes of this path to the storage, so fixpath can work.
15894   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
15895 
15896     else
15897       # We're on a unix platform. Hooray! :)
15898       path="$CURDIR"
15899       has_space=`$ECHO "$path" | $GREP " "`
15900       if test "x$has_space" != x; then
15901         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CURDIR, which resolves as \"$path\", is invalid." >&5
15902 $as_echo "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid." >&6;}
15903         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
15904       fi
15905 
15906       # Use eval to expand a potential ~
15907       eval path="$path"
15908       if test ! -f "$path" && test ! -d "$path"; then
15909         as_fn_error $? "The path of CURDIR, which resolves as \"$path\", is not found." "$LINENO" 5
15910       fi
15911 
15912       if test -d "$path"; then
15913         CURDIR="`cd "$path"; $THEPWDCMD -L`"
15914       else
15915         dir="`$DIRNAME "$path"`"
15916         base="`$BASENAME "$path"`"
15917         CURDIR="`cd "$dir"; $THEPWDCMD -L`/$base"
15918       fi
15919     fi
15920   fi
15921 
15922 
15923   # Only process if variable expands to non-empty
15924 
15925   if test "x$TOPDIR" != x; then
15926     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15927 
15928   # Input might be given as Windows format, start by converting to
15929   # unix format.
15930   path="$TOPDIR"
15931   new_path=`$CYGPATH -u "$path"`
15932 
15933   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
15934   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
15935   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
15936   # "foo.exe" is OK but "foo" is an error.
15937   #
15938   # This test is therefore slightly more accurate than "test -f" to check for file precense.
15939   # It is also a way to make sure we got the proper file name for the real test later on.
15940   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
15941   if test "x$test_shortpath" = x; then
15942     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of TOPDIR, which resolves as \"$path\", is invalid." >&5
15943 $as_echo "$as_me: The path of TOPDIR, which resolves as \"$path\", is invalid." >&6;}
15944     as_fn_error $? "Cannot locate the the path of TOPDIR" "$LINENO" 5
15945   fi
15946 
15947   # Call helper function which possibly converts this using DOS-style short mode.
15948   # If so, the updated path is stored in $new_path.
15949 
15950   input_path="$new_path"
15951   # Check if we need to convert this using DOS-style short mode. If the path
15952   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15953   # take no chances and rewrite it.
15954   # Note: m4 eats our [], so we need to use [ and ] instead.
15955   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
15956   if test "x$has_forbidden_chars" != x; then
15957     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15958     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
15959     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
15960     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
15961       # Going to short mode and back again did indeed matter. Since short mode is
15962       # case insensitive, let's make it lowercase to improve readability.
15963       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15964       # Now convert it back to Unix-style (cygpath)
15965       input_path=`$CYGPATH -u "$shortmode_path"`
15966       new_path="$input_path"
15967     fi
15968   fi
15969 
15970   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
15971   if test "x$test_cygdrive_prefix" = x; then
15972     # As a simple fix, exclude /usr/bin since it's not a real path.
15973     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
15974       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
15975       # a path prefixed by /cygdrive for fixpath to work.
15976       new_path="$CYGWIN_ROOT_PATH$input_path"
15977     fi
15978   fi
15979 
15980 
15981   if test "x$path" != "x$new_path"; then
15982     TOPDIR="$new_path"
15983     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting TOPDIR to \"$new_path\"" >&5
15984 $as_echo "$as_me: Rewriting TOPDIR to \"$new_path\"" >&6;}
15985   fi
15986 
15987     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15988 
15989   path="$TOPDIR"
15990   has_colon=`$ECHO $path | $GREP ^.:`
15991   new_path="$path"
15992   if test "x$has_colon" = x; then
15993     # Not in mixed or Windows style, start by that.
15994     new_path=`cmd //c echo $path`
15995   fi
15996 
15997 
15998   input_path="$new_path"
15999   # Check if we need to convert this using DOS-style short mode. If the path
16000   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16001   # take no chances and rewrite it.
16002   # Note: m4 eats our [], so we need to use [ and ] instead.
16003   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
16004   if test "x$has_forbidden_chars" != x; then
16005     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16006     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16007   fi
16008 
16009 
16010   windows_path="$new_path"
16011   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16012     unix_path=`$CYGPATH -u "$windows_path"`
16013     new_path="$unix_path"
16014   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16015     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16016     new_path="$unix_path"
16017   fi
16018 
16019   if test "x$path" != "x$new_path"; then
16020     TOPDIR="$new_path"
16021     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting TOPDIR to \"$new_path\"" >&5
16022 $as_echo "$as_me: Rewriting TOPDIR to \"$new_path\"" >&6;}
16023   fi
16024 
16025   # Save the first 10 bytes of this path to the storage, so fixpath can work.
16026   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
16027 
16028     else
16029       # We're on a unix platform. Hooray! :)
16030       path="$TOPDIR"
16031       has_space=`$ECHO "$path" | $GREP " "`
16032       if test "x$has_space" != x; then
16033         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of TOPDIR, which resolves as \"$path\", is invalid." >&5
16034 $as_echo "$as_me: The path of TOPDIR, which resolves as \"$path\", is invalid." >&6;}
16035         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
16036       fi
16037 
16038       # Use eval to expand a potential ~
16039       eval path="$path"
16040       if test ! -f "$path" && test ! -d "$path"; then
16041         as_fn_error $? "The path of TOPDIR, which resolves as \"$path\", is not found." "$LINENO" 5
16042       fi
16043 
16044       if test -d "$path"; then
16045         TOPDIR="`cd "$path"; $THEPWDCMD -L`"
16046       else
16047         dir="`$DIRNAME "$path"`"
16048         base="`$BASENAME "$path"`"
16049         TOPDIR="`cd "$dir"; $THEPWDCMD -L`/$base"
16050       fi
16051     fi
16052   fi
16053 
16054   # SRC_ROOT is a traditional alias for TOPDIR.
16055   SRC_ROOT=$TOPDIR
16056 
16057   # Calculate a canonical version of TOPDIR for string comparisons
16058   CANONICAL_TOPDIR=$TOPDIR
16059 
16060   if test "x$OPENJDK_BUILD_OS" != xwindows; then
16061     # Follow a chain of symbolic links. Use readlink
16062     # where it exists, else fall back to horribly
16063     # complicated shell code.
16064     if test "x$READLINK_TESTED" != yes; then
16065       # On MacOSX there is a readlink tool with a different
16066       # purpose than the GNU readlink tool. Check the found readlink.
16067       ISGNU=`$READLINK --version 2>&1 | $GREP GNU`
16068       if test "x$ISGNU" = x; then
16069         # A readlink that we do not know how to use.
16070         # Are there other non-GNU readlinks out there?
16071         READLINK_TESTED=yes
16072         READLINK=
16073       fi
16074     fi
16075 
16076     if test "x$READLINK" != x; then
16077       CANONICAL_TOPDIR=`$READLINK -f $CANONICAL_TOPDIR`
16078     else
16079       # Save the current directory for restoring afterwards
16080       STARTDIR=$PWD
16081       COUNTER=0
16082       sym_link_dir=`$DIRNAME $CANONICAL_TOPDIR`
16083       sym_link_file=`$BASENAME $CANONICAL_TOPDIR`
16084       cd $sym_link_dir
16085       # Use -P flag to resolve symlinks in directories.
16086       cd `$THEPWDCMD -P`
16087       sym_link_dir=`$THEPWDCMD -P`
16088       # Resolve file symlinks
16089       while test $COUNTER -lt 20; do
16090         ISLINK=`$LS -l $sym_link_dir/$sym_link_file | $GREP '\->' | $SED -e 's/.*-> \(.*\)/\1/'`
16091         if test "x$ISLINK" == x; then
16092           # This is not a symbolic link! We are done!
16093           break
16094         fi
16095         # Again resolve directory symlinks since the target of the just found
16096         # link could be in a different directory
16097         cd `$DIRNAME $ISLINK`
16098         sym_link_dir=`$THEPWDCMD -P`
16099         sym_link_file=`$BASENAME $ISLINK`
16100         let COUNTER=COUNTER+1
16101       done
16102       cd $STARTDIR
16103       CANONICAL_TOPDIR=$sym_link_dir/$sym_link_file
16104     fi
16105   fi
16106 
16107 
16108 
16109   # Locate the directory of this script.
16110   AUTOCONF_DIR=$TOPDIR/common/autoconf
16111 
16112   # Setup username (for use in adhoc version strings etc)
16113   # Outer [ ] to quote m4.
16114    USERNAME=`$ECHO "$USER" | $TR -d -c '[a-z][A-Z][0-9]'`
16115 
16116 
16117 
16118 # Check if it's a pure open build or if custom sources are to be used.
16119 
16120   # Check whether --enable-openjdk-only was given.
16121 if test "${enable_openjdk_only+set}" = set; then :
16122   enableval=$enable_openjdk_only;
16123 else
16124   enable_openjdk_only="no"
16125 fi
16126 
16127 
16128   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for presence of closed sources" >&5
16129 $as_echo_n "checking for presence of closed sources... " >&6; }
16130   if test -d "$SRC_ROOT/jdk/src/closed"; then
16131     CLOSED_SOURCE_PRESENT=yes
16132   else
16133     CLOSED_SOURCE_PRESENT=no
16134   fi
16135   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CLOSED_SOURCE_PRESENT" >&5
16136 $as_echo "$CLOSED_SOURCE_PRESENT" >&6; }
16137 
16138   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if closed source is suppressed (openjdk-only)" >&5
16139 $as_echo_n "checking if closed source is suppressed (openjdk-only)... " >&6; }
16140   SUPPRESS_CLOSED_SOURCE="$enable_openjdk_only"
16141   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SUPPRESS_CLOSED_SOURCE" >&5
16142 $as_echo "$SUPPRESS_CLOSED_SOURCE" >&6; }
16143 
16144   if test "x$CLOSED_SOURCE_PRESENT" = xno; then
16145     OPENJDK=true
16146     if test "x$SUPPRESS_CLOSED_SOURCE" = "xyes"; then
16147       { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No closed source present, --enable-openjdk-only makes no sense" >&5
16148 $as_echo "$as_me: WARNING: No closed source present, --enable-openjdk-only makes no sense" >&2;}
16149     fi
16150   else
16151     if test "x$SUPPRESS_CLOSED_SOURCE" = "xyes"; then
16152       OPENJDK=true
16153     else
16154       OPENJDK=false
16155     fi
16156   fi
16157 
16158   if test "x$OPENJDK" = "xtrue"; then
16159     SET_OPENJDK="OPENJDK=true"
16160   fi
16161 
16162 
16163 
16164   # custom-make-dir is deprecated. Please use your custom-hook.m4 to override
16165   # the IncludeCustomExtension macro.
16166 
16167 
16168 # Check whether --with-custom-make-dir was given.
16169 if test "${with_custom_make_dir+set}" = set; then :
16170   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
16171 $as_echo "$as_me: WARNING: Option --with-custom-make-dir is deprecated and will be ignored." >&2;}
16172 fi
16173 
16174 
16175 
16176 
16177 # These are needed to be able to create a configuration name (and thus the output directory)
16178 
16179   { $as_echo "$as_me:${as_lineno-$LINENO}: checking which variant of the JDK to build" >&5
16180 $as_echo_n "checking which variant of the JDK to build... " >&6; }
16181 
16182 # Check whether --with-jdk-variant was given.
16183 if test "${with_jdk_variant+set}" = set; then :
16184   withval=$with_jdk_variant;
16185 fi
16186 
16187 
16188   if test "x$with_jdk_variant" = xnormal || test "x$with_jdk_variant" = x; then
16189     JDK_VARIANT="normal"
16190   else
16191     as_fn_error $? "The available JDK variants are: normal" "$LINENO" 5
16192   fi
16193 
16194 
16195 
16196   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JDK_VARIANT" >&5
16197 $as_echo "$JDK_VARIANT" >&6; }
16198 
16199 
16200   DEBUG_LEVEL="release"
16201   { $as_echo "$as_me:${as_lineno-$LINENO}: checking which debug level to use" >&5
16202 $as_echo_n "checking which debug level to use... " >&6; }
16203   # Check whether --enable-debug was given.
16204 if test "${enable_debug+set}" = set; then :
16205   enableval=$enable_debug;
16206         ENABLE_DEBUG="${enableval}"
16207         DEBUG_LEVEL="fastdebug"
16208 
16209 else
16210   ENABLE_DEBUG="no"
16211 fi
16212 
16213 
16214 
16215 # Check whether --with-debug-level was given.
16216 if test "${with_debug_level+set}" = set; then :
16217   withval=$with_debug_level;
16218         DEBUG_LEVEL="${withval}"
16219         if test "x$ENABLE_DEBUG" = xyes; then
16220           as_fn_error $? "You cannot use both --enable-debug and --with-debug-level at the same time." "$LINENO" 5
16221         fi
16222 
16223 fi
16224 
16225   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEBUG_LEVEL" >&5
16226 $as_echo "$DEBUG_LEVEL" >&6; }
16227 
16228   if test "x$DEBUG_LEVEL" != xrelease && \
16229       test "x$DEBUG_LEVEL" != xoptimized && \
16230       test "x$DEBUG_LEVEL" != xfastdebug && \
16231       test "x$DEBUG_LEVEL" != xslowdebug; then
16232     as_fn_error $? "Allowed debug levels are: release, fastdebug, slowdebug and optimized" "$LINENO" 5
16233   fi
16234 
16235   # Translate DEBUG_LEVEL to debug level used by Hotspot
16236   HOTSPOT_DEBUG_LEVEL="$DEBUG_LEVEL"
16237   if test "x$DEBUG_LEVEL" = xrelease; then
16238     HOTSPOT_DEBUG_LEVEL="product"
16239   elif test "x$DEBUG_LEVEL" = xslowdebug; then
16240     HOTSPOT_DEBUG_LEVEL="debug"
16241   fi
16242 
16243   if test "x$DEBUG_LEVEL" = xoptimized; then
16244     # The debug level 'optimized' is a little special because it is currently only
16245     # applicable to the HotSpot build where it means to build a completely
16246     # optimized version of the VM without any debugging code (like for the
16247     # 'release' debug level which is called 'product' in the HotSpot build) but
16248     # with the exception that it can contain additional code which is otherwise
16249     # protected by '#ifndef PRODUCT' macros. These 'optimized' builds are used to
16250     # test new and/or experimental features which are not intended for customer
16251     # shipment. Because these new features need to be tested and benchmarked in
16252     # real world scenarios, we want to build the containing JDK at the 'release'
16253     # debug level.
16254     DEBUG_LEVEL="release"
16255   fi
16256 
16257 
16258 
16259 
16260 
16261 
16262 # Check whether --with-jvm-variants was given.
16263 if test "${with_jvm_variants+set}" = set; then :
16264   withval=$with_jvm_variants;
16265 fi
16266 
16267 
16268   if test "x$with_jvm_variants" = x; then
16269     with_jvm_variants="server"
16270   fi
16271   JVM_VARIANTS_OPT="$with_jvm_variants"
16272 
16273   # Has the user listed more than one variant?
16274   # Additional [] needed to keep m4 from mangling shell constructs.
16275   if  [[ "$JVM_VARIANTS_OPT" =~ "," ]] ; then
16276     BUILDING_MULTIPLE_JVM_VARIANTS=true
16277   else
16278     BUILDING_MULTIPLE_JVM_VARIANTS=false
16279   fi
16280   # Replace the commas with AND for use in the build directory name.
16281   JVM_VARIANTS_WITH_AND=`$ECHO "$JVM_VARIANTS_OPT" | $SED -e 's/,/AND/g'`
16282 
16283   { $as_echo "$as_me:${as_lineno-$LINENO}: checking which variants of the JVM to build" >&5
16284 $as_echo_n "checking which variants of the JVM to build... " >&6; }
16285   # JVM_VARIANTS is a space-separated list.
16286   # Also use minimal, not minimal1 (which is kept for backwards compatibility).
16287   JVM_VARIANTS=`$ECHO $JVM_VARIANTS_OPT | $SED -e 's/,/ /g' -e 's/minimal1/minimal/'`
16288   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JVM_VARIANTS" >&5
16289 $as_echo "$JVM_VARIANTS" >&6; }
16290 
16291   # Check that the selected variants are valid
16292 
16293   # grep filter function inspired by a comment to http://stackoverflow.com/a/1617326
16294   # Notice that the original variant failes on SLES 10 and 11
16295   NEEDLE=${VALID_JVM_VARIANTS// /$'\n'}
16296   STACK=${JVM_VARIANTS// /$'\n'}
16297   INVALID_VARIANTS=`$GREP -Fvx "${NEEDLE}" <<< "${STACK}"`
16298   if test "x$INVALID_VARIANTS" != x; then
16299     { $as_echo "$as_me:${as_lineno-$LINENO}: Unknown variant(s) specified: $INVALID_VARIANTS" >&5
16300 $as_echo "$as_me: Unknown variant(s) specified: $INVALID_VARIANTS" >&6;}
16301     as_fn_error $? "The available JVM variants are: $VALID_JVM_VARIANTS" "$LINENO" 5
16302   fi
16303 
16304   # All "special" variants share the same output directory ("server")
16305   VALID_MULTIPLE_JVM_VARIANTS="server client minimal"
16306   NEEDLE=${VALID_MULTIPLE_JVM_VARIANTS// /$'\n'}
16307   STACK=${JVM_VARIANTS// /$'\n'}
16308   INVALID_MULTIPLE_VARIANTS=`$GREP -Fvx "${NEEDLE}" <<< "${STACK}"`
16309   if  test "x$INVALID_MULTIPLE_VARIANTS" != x && test "x$BUILDING_MULTIPLE_JVM_VARIANTS" = xtrue; then
16310     as_fn_error $? "You cannot build multiple variants with anything else than $VALID_MULTIPLE_JVM_VARIANTS." "$LINENO" 5
16311   fi
16312 
16313 
16314 
16315 
16316   if   [[ " $JVM_VARIANTS " =~ " zero " ]]   ||   [[ " $JVM_VARIANTS " =~ " zeroshark " ]]  ; then
16317     # zero behaves as a platform and rewrites these values. This is really weird. :(
16318     # We are guaranteed that we do not build any other variants when building zero.
16319     HOTSPOT_TARGET_CPU=zero
16320     HOTSPOT_TARGET_CPU_ARCH=zero
16321   fi
16322 
16323 
16324 # With basic setup done, call the custom early hook.
16325 
16326 
16327 # Check if we have devkits, extra paths or sysroot set.
16328 
16329 
16330 # Check whether --with-devkit was given.
16331 if test "${with_devkit+set}" = set; then :
16332   withval=$with_devkit;
16333 
16334   # Only process if variable expands to non-empty
16335 
16336   if test "x$with_devkit" != x; then
16337     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16338 
16339   # Input might be given as Windows format, start by converting to
16340   # unix format.
16341   path="$with_devkit"
16342   new_path=`$CYGPATH -u "$path"`
16343 
16344   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
16345   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
16346   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
16347   # "foo.exe" is OK but "foo" is an error.
16348   #
16349   # This test is therefore slightly more accurate than "test -f" to check for file precense.
16350   # It is also a way to make sure we got the proper file name for the real test later on.
16351   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
16352   if test "x$test_shortpath" = x; then
16353     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
16354 $as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
16355     as_fn_error $? "Cannot locate the the path of with_devkit" "$LINENO" 5
16356   fi
16357 
16358   # Call helper function which possibly converts this using DOS-style short mode.
16359   # If so, the updated path is stored in $new_path.
16360 
16361   input_path="$new_path"
16362   # Check if we need to convert this using DOS-style short mode. If the path
16363   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16364   # take no chances and rewrite it.
16365   # Note: m4 eats our [], so we need to use [ and ] instead.
16366   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
16367   if test "x$has_forbidden_chars" != x; then
16368     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16369     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
16370     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
16371     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
16372       # Going to short mode and back again did indeed matter. Since short mode is
16373       # case insensitive, let's make it lowercase to improve readability.
16374       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16375       # Now convert it back to Unix-style (cygpath)
16376       input_path=`$CYGPATH -u "$shortmode_path"`
16377       new_path="$input_path"
16378     fi
16379   fi
16380 
16381   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
16382   if test "x$test_cygdrive_prefix" = x; then
16383     # As a simple fix, exclude /usr/bin since it's not a real path.
16384     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
16385       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
16386       # a path prefixed by /cygdrive for fixpath to work.
16387       new_path="$CYGWIN_ROOT_PATH$input_path"
16388     fi
16389   fi
16390 
16391 
16392   if test "x$path" != "x$new_path"; then
16393     with_devkit="$new_path"
16394     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
16395 $as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
16396   fi
16397 
16398     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16399 
16400   path="$with_devkit"
16401   has_colon=`$ECHO $path | $GREP ^.:`
16402   new_path="$path"
16403   if test "x$has_colon" = x; then
16404     # Not in mixed or Windows style, start by that.
16405     new_path=`cmd //c echo $path`
16406   fi
16407 
16408 
16409   input_path="$new_path"
16410   # Check if we need to convert this using DOS-style short mode. If the path
16411   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16412   # take no chances and rewrite it.
16413   # Note: m4 eats our [], so we need to use [ and ] instead.
16414   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
16415   if test "x$has_forbidden_chars" != x; then
16416     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16417     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16418   fi
16419 
16420 
16421   windows_path="$new_path"
16422   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16423     unix_path=`$CYGPATH -u "$windows_path"`
16424     new_path="$unix_path"
16425   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16426     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16427     new_path="$unix_path"
16428   fi
16429 
16430   if test "x$path" != "x$new_path"; then
16431     with_devkit="$new_path"
16432     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
16433 $as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
16434   fi
16435 
16436   # Save the first 10 bytes of this path to the storage, so fixpath can work.
16437   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
16438 
16439     else
16440       # We're on a unix platform. Hooray! :)
16441       path="$with_devkit"
16442       has_space=`$ECHO "$path" | $GREP " "`
16443       if test "x$has_space" != x; then
16444         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
16445 $as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
16446         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
16447       fi
16448 
16449       # Use eval to expand a potential ~
16450       eval path="$path"
16451       if test ! -f "$path" && test ! -d "$path"; then
16452         as_fn_error $? "The path of with_devkit, which resolves as \"$path\", is not found." "$LINENO" 5
16453       fi
16454 
16455       if test -d "$path"; then
16456         with_devkit="`cd "$path"; $THEPWDCMD -L`"
16457       else
16458         dir="`$DIRNAME "$path"`"
16459         base="`$BASENAME "$path"`"
16460         with_devkit="`cd "$dir"; $THEPWDCMD -L`/$base"
16461       fi
16462     fi
16463   fi
16464 
16465         DEVKIT_ROOT="$with_devkit"
16466         # Check for a meta data info file in the root of the devkit
16467         if test -f "$DEVKIT_ROOT/devkit.info"; then
16468           . $DEVKIT_ROOT/devkit.info
16469           # This potentially sets the following:
16470           # A descriptive name of the devkit
16471 
16472   if test "x$DEVKIT_NAME" = x; then
16473     eval DEVKIT_NAME="\${DEVKIT_NAME_${OPENJDK_TARGET_CPU}}"
16474   fi
16475 
16476           # Corresponds to --with-extra-path
16477 
16478   if test "x$DEVKIT_EXTRA_PATH" = x; then
16479     eval DEVKIT_EXTRA_PATH="\${DEVKIT_EXTRA_PATH_${OPENJDK_TARGET_CPU}}"
16480   fi
16481 
16482           # Corresponds to --with-toolchain-path
16483 
16484   if test "x$DEVKIT_TOOLCHAIN_PATH" = x; then
16485     eval DEVKIT_TOOLCHAIN_PATH="\${DEVKIT_TOOLCHAIN_PATH_${OPENJDK_TARGET_CPU}}"
16486   fi
16487 
16488           # Corresponds to --with-sysroot
16489 
16490   if test "x$DEVKIT_SYSROOT" = x; then
16491     eval DEVKIT_SYSROOT="\${DEVKIT_SYSROOT_${OPENJDK_TARGET_CPU}}"
16492   fi
16493 
16494 
16495           # Identifies the Visual Studio version in the devkit
16496 
16497   if test "x$DEVKIT_VS_VERSION" = x; then
16498     eval DEVKIT_VS_VERSION="\${DEVKIT_VS_VERSION_${OPENJDK_TARGET_CPU}}"
16499   fi
16500 
16501           # The Visual Studio include environment variable
16502 
16503   if test "x$DEVKIT_VS_INCLUDE" = x; then
16504     eval DEVKIT_VS_INCLUDE="\${DEVKIT_VS_INCLUDE_${OPENJDK_TARGET_CPU}}"
16505   fi
16506 
16507           # The Visual Studio lib environment variable
16508 
16509   if test "x$DEVKIT_VS_LIB" = x; then
16510     eval DEVKIT_VS_LIB="\${DEVKIT_VS_LIB_${OPENJDK_TARGET_CPU}}"
16511   fi
16512 
16513           # Corresponds to --with-msvcr-dll
16514 
16515   if test "x$DEVKIT_MSVCR_DLL" = x; then
16516     eval DEVKIT_MSVCR_DLL="\${DEVKIT_MSVCR_DLL_${OPENJDK_TARGET_CPU}}"
16517   fi
16518 
16519           # Corresponds to --with-msvcp-dll
16520 
16521   if test "x$DEVKIT_MSVCP_DLL" = x; then
16522     eval DEVKIT_MSVCP_DLL="\${DEVKIT_MSVCP_DLL_${OPENJDK_TARGET_CPU}}"
16523   fi
16524 
16525         fi
16526 
16527         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for devkit" >&5
16528 $as_echo_n "checking for devkit... " >&6; }
16529         if test "x$DEVKIT_NAME" != x; then
16530           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEVKIT_NAME in $DEVKIT_ROOT" >&5
16531 $as_echo "$DEVKIT_NAME in $DEVKIT_ROOT" >&6; }
16532         else
16533           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEVKIT_ROOT" >&5
16534 $as_echo "$DEVKIT_ROOT" >&6; }
16535         fi
16536 
16537 
16538   if test "x$DEVKIT_EXTRA_PATH" != x; then
16539     if test "x$EXTRA_PATH" = x; then
16540       EXTRA_PATH="$DEVKIT_EXTRA_PATH"
16541     else
16542       EXTRA_PATH="$DEVKIT_EXTRA_PATH:$EXTRA_PATH"
16543     fi
16544   fi
16545 
16546 
16547         # Fallback default of just /bin if DEVKIT_PATH is not defined
16548         if test "x$DEVKIT_TOOLCHAIN_PATH" = x; then
16549           DEVKIT_TOOLCHAIN_PATH="$DEVKIT_ROOT/bin"
16550         fi
16551 
16552   if test "x$DEVKIT_TOOLCHAIN_PATH" != x; then
16553     if test "x$TOOLCHAIN_PATH" = x; then
16554       TOOLCHAIN_PATH="$DEVKIT_TOOLCHAIN_PATH"
16555     else
16556       TOOLCHAIN_PATH="$DEVKIT_TOOLCHAIN_PATH:$TOOLCHAIN_PATH"
16557     fi
16558   fi
16559 
16560 
16561         # If DEVKIT_SYSROOT is set, use that, otherwise try a couple of known
16562         # places for backwards compatiblity.
16563         if test "x$DEVKIT_SYSROOT" != x; then
16564           SYSROOT="$DEVKIT_SYSROOT"
16565         elif test -d "$DEVKIT_ROOT/$host_alias/libc"; then
16566           SYSROOT="$DEVKIT_ROOT/$host_alias/libc"
16567         elif test -d "$DEVKIT_ROOT/$host/sys-root"; then
16568           SYSROOT="$DEVKIT_ROOT/$host/sys-root"
16569         fi
16570 
16571 
16572 fi
16573 
16574 
16575   # You can force the sysroot if the sysroot encoded into the compiler tools
16576   # is not correct.
16577 
16578 # Check whether --with-sys-root was given.
16579 if test "${with_sys_root+set}" = set; then :
16580   withval=$with_sys_root; SYSROOT=$with_sys_root
16581 
16582 fi
16583 
16584 
16585 
16586 # Check whether --with-sysroot was given.
16587 if test "${with_sysroot+set}" = set; then :
16588   withval=$with_sysroot; SYSROOT=$with_sysroot
16589 
16590 fi
16591 
16592 
16593 
16594 # Check whether --with-tools-dir was given.
16595 if test "${with_tools_dir+set}" = set; then :
16596   withval=$with_tools_dir;
16597   if test "x$with_tools_dir" != x; then
16598     if test "x$TOOLCHAIN_PATH" = x; then
16599       TOOLCHAIN_PATH="$with_tools_dir"
16600     else
16601       TOOLCHAIN_PATH="$with_tools_dir:$TOOLCHAIN_PATH"
16602     fi
16603   fi
16604 
16605 
16606 fi
16607 
16608 
16609 
16610 # Check whether --with-toolchain-path was given.
16611 if test "${with_toolchain_path+set}" = set; then :
16612   withval=$with_toolchain_path;
16613   if test "x$with_toolchain_path" != x; then
16614     if test "x$TOOLCHAIN_PATH" = x; then
16615       TOOLCHAIN_PATH="$with_toolchain_path"
16616     else
16617       TOOLCHAIN_PATH="$with_toolchain_path:$TOOLCHAIN_PATH"
16618     fi
16619   fi
16620 
16621 
16622 fi
16623 
16624 
16625 
16626 # Check whether --with-extra-path was given.
16627 if test "${with_extra_path+set}" = set; then :
16628   withval=$with_extra_path;
16629   if test "x$with_extra_path" != x; then
16630     if test "x$EXTRA_PATH" = x; then
16631       EXTRA_PATH="$with_extra_path"
16632     else
16633       EXTRA_PATH="$with_extra_path:$EXTRA_PATH"
16634     fi
16635   fi
16636 
16637 
16638 fi
16639 
16640 
16641   if test "x$OPENJDK_BUILD_OS" = "xmacosx"; then
16642     # If a devkit has been supplied, find xcodebuild in the toolchain_path.
16643     # If not, detect if Xcode is installed by running xcodebuild -version
16644     # if no Xcode installed, xcodebuild exits with 1
16645     # if Xcode is installed, even if xcode-select is misconfigured, then it exits with 0
16646     if test "x$DEVKIT_ROOT" != x || /usr/bin/xcodebuild -version >/dev/null 2>&1; then
16647       # We need to use xcodebuild in the toolchain dir provided by the user, this will
16648       # fall back on the stub binary in /usr/bin/xcodebuild
16649       # Extract the first word of "xcodebuild", so it can be a program name with args.
16650 set dummy xcodebuild; ac_word=$2
16651 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
16652 $as_echo_n "checking for $ac_word... " >&6; }
16653 if ${ac_cv_path_XCODEBUILD+:} false; then :
16654   $as_echo_n "(cached) " >&6
16655 else
16656   case $XCODEBUILD in
16657   [\\/]* | ?:[\\/]*)
16658   ac_cv_path_XCODEBUILD="$XCODEBUILD" # Let the user override the test with a path.
16659   ;;
16660   *)
16661   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
16662 for as_dir in $TOOLCHAIN_PATH
16663 do
16664   IFS=$as_save_IFS
16665   test -z "$as_dir" && as_dir=.
16666     for ac_exec_ext in '' $ac_executable_extensions; do
16667   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
16668     ac_cv_path_XCODEBUILD="$as_dir/$ac_word$ac_exec_ext"
16669     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
16670     break 2
16671   fi
16672 done
16673   done
16674 IFS=$as_save_IFS
16675 
16676   test -z "$ac_cv_path_XCODEBUILD" && ac_cv_path_XCODEBUILD="/usr/bin/xcodebuild"
16677   ;;
16678 esac
16679 fi
16680 XCODEBUILD=$ac_cv_path_XCODEBUILD
16681 if test -n "$XCODEBUILD"; then
16682   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XCODEBUILD" >&5
16683 $as_echo "$XCODEBUILD" >&6; }
16684 else
16685   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
16686 $as_echo "no" >&6; }
16687 fi
16688 
16689 
16690     else
16691       # this should result in SYSROOT being empty, unless --with-sysroot is provided
16692       # when only the command line tools are installed there are no SDKs, so headers
16693       # are copied into the system frameworks
16694       XCODEBUILD=
16695 
16696     fi
16697 
16698     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for sdk name" >&5
16699 $as_echo_n "checking for sdk name... " >&6; }
16700 
16701 # Check whether --with-sdk-name was given.
16702 if test "${with_sdk_name+set}" = set; then :
16703   withval=$with_sdk_name; SDKNAME=$with_sdk_name
16704 
16705 fi
16706 
16707     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SDKNAME" >&5
16708 $as_echo "$SDKNAME" >&6; }
16709 
16710     # if toolchain path is specified then don't rely on system headers, they may not compile
16711     HAVE_SYSTEM_FRAMEWORK_HEADERS=0
16712     test -z "$TOOLCHAIN_PATH" && \
16713       HAVE_SYSTEM_FRAMEWORK_HEADERS=`test ! -f /System/Library/Frameworks/Foundation.framework/Headers/Foundation.h; echo $?`
16714 
16715     if test -z "$SYSROOT"; then
16716       if test -n "$XCODEBUILD"; then
16717         # if we don't have system headers, use default SDK name (last resort)
16718         if test -z "$SDKNAME" -a $HAVE_SYSTEM_FRAMEWORK_HEADERS -eq 0; then
16719           SDKNAME=${SDKNAME:-macosx}
16720         fi
16721 
16722         if test -n "$SDKNAME"; then
16723           # Call xcodebuild to determine SYSROOT
16724           SYSROOT=`"$XCODEBUILD" -sdk $SDKNAME -version | grep '^Path: ' | sed 's/Path: //'`
16725         fi
16726       else
16727         if test $HAVE_SYSTEM_FRAMEWORK_HEADERS -eq 0; then
16728           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
16729         fi
16730       fi
16731     else
16732       # warn user if --with-sdk-name was also set
16733       if test -n "$with_sdk_name"; then
16734         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Both SYSROOT and --with-sdk-name are set, only SYSROOT will be used" >&5
16735 $as_echo "$as_me: WARNING: Both SYSROOT and --with-sdk-name are set, only SYSROOT will be used" >&2;}
16736       fi
16737     fi
16738 
16739     if test $HAVE_SYSTEM_FRAMEWORK_HEADERS -eq 0 -a -z "$SYSROOT"; then
16740       # If no system framework headers, then SYSROOT must be set, or we won't build
16741       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
16742     fi
16743 
16744     # Perform a basic sanity test
16745     if test ! -f "$SYSROOT/System/Library/Frameworks/Foundation.framework/Headers/Foundation.h"; then
16746       if test -z "$SYSROOT"; then
16747         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
16748       else
16749         as_fn_error $? "Invalid SDK or SYSROOT path, dependent framework headers not found" "$LINENO" 5
16750       fi
16751     fi
16752 
16753     # set SDKROOT too, Xcode tools will pick it up
16754     SDKROOT=$SYSROOT
16755 
16756   fi
16757 
16758   # Prepend the extra path to the global path
16759 
16760   if test "x$EXTRA_PATH" != x; then
16761     if test "x$PATH" = x; then
16762       PATH="$EXTRA_PATH"
16763     else
16764       PATH="$EXTRA_PATH:$PATH"
16765     fi
16766   fi
16767 
16768 
16769   if test "x$OPENJDK_BUILD_OS" = "xsolaris"; then
16770     # Add extra search paths on solaris for utilities like ar, as, dtrace etc...
16771     PATH="$PATH:/usr/ccs/bin:/usr/sfw/bin:/opt/csw/bin:/usr/sbin"
16772   fi
16773 
16774   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for sysroot" >&5
16775 $as_echo_n "checking for sysroot... " >&6; }
16776   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SYSROOT" >&5
16777 $as_echo "$SYSROOT" >&6; }
16778   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for toolchain path" >&5
16779 $as_echo_n "checking for toolchain path... " >&6; }
16780   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOOLCHAIN_PATH" >&5
16781 $as_echo "$TOOLCHAIN_PATH" >&6; }
16782   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for extra path" >&5
16783 $as_echo_n "checking for extra path... " >&6; }
16784   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXTRA_PATH" >&5
16785 $as_echo "$EXTRA_PATH" >&6; }
16786 
16787 
16788 # To properly create a configuration name, we need to have the OpenJDK target
16789 # and options (variants and debug level) parsed.
16790 
16791 
16792 
16793 # Check whether --with-conf-name was given.
16794 if test "${with_conf_name+set}" = set; then :
16795   withval=$with_conf_name;  CONF_NAME=${with_conf_name}
16796 fi
16797 
16798 
16799   # Test from where we are running configure, in or outside of src root.
16800   { $as_echo "$as_me:${as_lineno-$LINENO}: checking where to store configuration" >&5
16801 $as_echo_n "checking where to store configuration... " >&6; }
16802   if test "x$CURDIR" = "x$SRC_ROOT" || test "x$CURDIR" = "x$SRC_ROOT/common" \
16803       || test "x$CURDIR" = "x$SRC_ROOT/common/autoconf" \
16804       || test "x$CURDIR" = "x$SRC_ROOT/make" ; then
16805     # We are running configure from the src root.
16806     # Create a default ./build/target-variant-debuglevel output root.
16807     if test "x${CONF_NAME}" = x; then
16808       { $as_echo "$as_me:${as_lineno-$LINENO}: result: in default location" >&5
16809 $as_echo "in default location" >&6; }
16810       CONF_NAME="${OPENJDK_TARGET_OS}-${OPENJDK_TARGET_CPU}-${JDK_VARIANT}-${JVM_VARIANTS_WITH_AND}-${DEBUG_LEVEL}"
16811     else
16812       { $as_echo "$as_me:${as_lineno-$LINENO}: result: in build directory with custom name" >&5
16813 $as_echo "in build directory with custom name" >&6; }
16814     fi
16815     OUTPUT_ROOT="$SRC_ROOT/build/${CONF_NAME}"
16816     $MKDIR -p "$OUTPUT_ROOT"
16817     if test ! -d "$OUTPUT_ROOT"; then
16818       as_fn_error $? "Could not create build directory $OUTPUT_ROOT" "$LINENO" 5
16819     fi
16820   else
16821     # We are running configure from outside of the src dir.
16822     # Then use the current directory as output dir!
16823     # If configuration is situated in normal build directory, just use the build
16824     # directory name as configuration name, otherwise use the complete path.
16825     if test "x${CONF_NAME}" = x; then
16826       CONF_NAME=`$ECHO $CURDIR | $SED -e "s!^${SRC_ROOT}/build/!!"`
16827     fi
16828     OUTPUT_ROOT="$CURDIR"
16829     { $as_echo "$as_me:${as_lineno-$LINENO}: result: in current directory" >&5
16830 $as_echo "in current directory" >&6; }
16831 
16832     # WARNING: This might be a bad thing to do. You need to be sure you want to
16833     # have a configuration in this directory. Do some sanity checks!
16834 
16835     if test ! -e "$OUTPUT_ROOT/spec.gmk"; then
16836       # If we have a spec.gmk, we have run here before and we are OK. Otherwise, check for
16837       # other files
16838       files_present=`$LS $OUTPUT_ROOT`
16839       # Configure has already touched config.log and confdefs.h in the current dir when this check
16840       # is performed.
16841       filtered_files=`$ECHO "$files_present" \
16842           | $SED -e 's/config.log//g' \
16843               -e 's/configure.log//g' \
16844               -e 's/confdefs.h//g' \
16845               -e 's/ //g' \
16846           | $TR -d '\n'`
16847       if test "x$filtered_files" != x; then
16848         { $as_echo "$as_me:${as_lineno-$LINENO}: Current directory is $CURDIR." >&5
16849 $as_echo "$as_me: Current directory is $CURDIR." >&6;}
16850         { $as_echo "$as_me:${as_lineno-$LINENO}: Since this is not the source root, configure will output the configuration here" >&5
16851 $as_echo "$as_me: Since this is not the source root, configure will output the configuration here" >&6;}
16852         { $as_echo "$as_me:${as_lineno-$LINENO}: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&5
16853 $as_echo "$as_me: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&6;}
16854         { $as_echo "$as_me:${as_lineno-$LINENO}: However, this directory is not empty. This is not allowed, since it could" >&5
16855 $as_echo "$as_me: However, this directory is not empty. This is not allowed, since it could" >&6;}
16856         { $as_echo "$as_me:${as_lineno-$LINENO}: seriously mess up just about everything." >&5
16857 $as_echo "$as_me: seriously mess up just about everything." >&6;}
16858         { $as_echo "$as_me:${as_lineno-$LINENO}: Try 'cd $SRC_ROOT' and restart configure" >&5
16859 $as_echo "$as_me: Try 'cd $SRC_ROOT' and restart configure" >&6;}
16860         { $as_echo "$as_me:${as_lineno-$LINENO}: (or create a new empty directory and cd to it)." >&5
16861 $as_echo "$as_me: (or create a new empty directory and cd to it)." >&6;}
16862         as_fn_error $? "Will not continue creating configuration in $CURDIR" "$LINENO" 5
16863       fi
16864     fi
16865   fi
16866   { $as_echo "$as_me:${as_lineno-$LINENO}: checking what configuration name to use" >&5
16867 $as_echo_n "checking what configuration name to use... " >&6; }
16868   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CONF_NAME" >&5
16869 $as_echo "$CONF_NAME" >&6; }
16870 
16871 
16872   # Only process if variable expands to non-empty
16873 
16874   if test "x$OUTPUT_ROOT" != x; then
16875     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16876 
16877   # Input might be given as Windows format, start by converting to
16878   # unix format.
16879   path="$OUTPUT_ROOT"
16880   new_path=`$CYGPATH -u "$path"`
16881 
16882   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
16883   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
16884   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
16885   # "foo.exe" is OK but "foo" is an error.
16886   #
16887   # This test is therefore slightly more accurate than "test -f" to check for file precense.
16888   # It is also a way to make sure we got the proper file name for the real test later on.
16889   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
16890   if test "x$test_shortpath" = x; then
16891     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&5
16892 $as_echo "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&6;}
16893     as_fn_error $? "Cannot locate the the path of OUTPUT_ROOT" "$LINENO" 5
16894   fi
16895 
16896   # Call helper function which possibly converts this using DOS-style short mode.
16897   # If so, the updated path is stored in $new_path.
16898 
16899   input_path="$new_path"
16900   # Check if we need to convert this using DOS-style short mode. If the path
16901   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16902   # take no chances and rewrite it.
16903   # Note: m4 eats our [], so we need to use [ and ] instead.
16904   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
16905   if test "x$has_forbidden_chars" != x; then
16906     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16907     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
16908     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
16909     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
16910       # Going to short mode and back again did indeed matter. Since short mode is
16911       # case insensitive, let's make it lowercase to improve readability.
16912       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16913       # Now convert it back to Unix-style (cygpath)
16914       input_path=`$CYGPATH -u "$shortmode_path"`
16915       new_path="$input_path"
16916     fi
16917   fi
16918 
16919   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
16920   if test "x$test_cygdrive_prefix" = x; then
16921     # As a simple fix, exclude /usr/bin since it's not a real path.
16922     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
16923       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
16924       # a path prefixed by /cygdrive for fixpath to work.
16925       new_path="$CYGWIN_ROOT_PATH$input_path"
16926     fi
16927   fi
16928 
16929 
16930   if test "x$path" != "x$new_path"; then
16931     OUTPUT_ROOT="$new_path"
16932     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
16933 $as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
16934   fi
16935 
16936     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16937 
16938   path="$OUTPUT_ROOT"
16939   has_colon=`$ECHO $path | $GREP ^.:`
16940   new_path="$path"
16941   if test "x$has_colon" = x; then
16942     # Not in mixed or Windows style, start by that.
16943     new_path=`cmd //c echo $path`
16944   fi
16945 
16946 
16947   input_path="$new_path"
16948   # Check if we need to convert this using DOS-style short mode. If the path
16949   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16950   # take no chances and rewrite it.
16951   # Note: m4 eats our [], so we need to use [ and ] instead.
16952   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
16953   if test "x$has_forbidden_chars" != x; then
16954     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16955     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16956   fi
16957 
16958 
16959   windows_path="$new_path"
16960   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16961     unix_path=`$CYGPATH -u "$windows_path"`
16962     new_path="$unix_path"
16963   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16964     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16965     new_path="$unix_path"
16966   fi
16967 
16968   if test "x$path" != "x$new_path"; then
16969     OUTPUT_ROOT="$new_path"
16970     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
16971 $as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
16972   fi
16973 
16974   # Save the first 10 bytes of this path to the storage, so fixpath can work.
16975   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
16976 
16977     else
16978       # We're on a unix platform. Hooray! :)
16979       path="$OUTPUT_ROOT"
16980       has_space=`$ECHO "$path" | $GREP " "`
16981       if test "x$has_space" != x; then
16982         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&5
16983 $as_echo "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&6;}
16984         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
16985       fi
16986 
16987       # Use eval to expand a potential ~
16988       eval path="$path"
16989       if test ! -f "$path" && test ! -d "$path"; then
16990         as_fn_error $? "The path of OUTPUT_ROOT, which resolves as \"$path\", is not found." "$LINENO" 5
16991       fi
16992 
16993       if test -d "$path"; then
16994         OUTPUT_ROOT="`cd "$path"; $THEPWDCMD -L`"
16995       else
16996         dir="`$DIRNAME "$path"`"
16997         base="`$BASENAME "$path"`"
16998         OUTPUT_ROOT="`cd "$dir"; $THEPWDCMD -L`/$base"
16999       fi
17000     fi
17001   fi
17002 
17003 
17004   CONFIGURESUPPORT_OUTPUTDIR="$OUTPUT_ROOT/configure-support"
17005   $MKDIR -p "$CONFIGURESUPPORT_OUTPUTDIR"
17006 
17007   SPEC=$OUTPUT_ROOT/spec.gmk
17008 
17009   CONF_NAME=$CONF_NAME
17010 
17011   OUTPUT_ROOT=$OUTPUT_ROOT
17012 
17013 
17014 
17015   # The spec.gmk file contains all variables for the make system.
17016   ac_config_files="$ac_config_files $OUTPUT_ROOT/spec.gmk:$AUTOCONF_DIR/spec.gmk.in"
17017 
17018   # The hotspot-spec.gmk file contains legacy variables for the hotspot make system.
17019   ac_config_files="$ac_config_files $OUTPUT_ROOT/hotspot-spec.gmk:$AUTOCONF_DIR/hotspot-spec.gmk.in"
17020 
17021   # The bootcycle-spec.gmk file contains support for boot cycle builds.
17022   ac_config_files="$ac_config_files $OUTPUT_ROOT/bootcycle-spec.gmk:$AUTOCONF_DIR/bootcycle-spec.gmk.in"
17023 
17024   # The buildjdk-spec.gmk file contains support for building a buildjdk when cross compiling.
17025   ac_config_files="$ac_config_files $OUTPUT_ROOT/buildjdk-spec.gmk:$AUTOCONF_DIR/buildjdk-spec.gmk.in"
17026 
17027   # The compare.sh is used to compare the build output to other builds.
17028   ac_config_files="$ac_config_files $OUTPUT_ROOT/compare.sh:$AUTOCONF_DIR/compare.sh.in"
17029 
17030   # The generated Makefile knows where the spec.gmk is and where the source is.
17031   # You can run make from the OUTPUT_ROOT, or from the top-level Makefile
17032   # which will look for generated configurations
17033   ac_config_files="$ac_config_files $OUTPUT_ROOT/Makefile:$AUTOCONF_DIR/Makefile.in"
17034 
17035 
17036 
17037 # Must be done before we can call HELP_MSG_MISSING_DEPENDENCY.
17038 
17039   for ac_prog in apt-get yum port pkgutil pkgadd
17040 do
17041   # Extract the first word of "$ac_prog", so it can be a program name with args.
17042 set dummy $ac_prog; ac_word=$2
17043 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17044 $as_echo_n "checking for $ac_word... " >&6; }
17045 if ${ac_cv_prog_PKGHANDLER+:} false; then :
17046   $as_echo_n "(cached) " >&6
17047 else
17048   if test -n "$PKGHANDLER"; then
17049   ac_cv_prog_PKGHANDLER="$PKGHANDLER" # Let the user override the test.
17050 else
17051 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17052 for as_dir in $PATH
17053 do
17054   IFS=$as_save_IFS
17055   test -z "$as_dir" && as_dir=.
17056     for ac_exec_ext in '' $ac_executable_extensions; do
17057   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17058     ac_cv_prog_PKGHANDLER="$ac_prog"
17059     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17060     break 2
17061   fi
17062 done
17063   done
17064 IFS=$as_save_IFS
17065 
17066 fi
17067 fi
17068 PKGHANDLER=$ac_cv_prog_PKGHANDLER
17069 if test -n "$PKGHANDLER"; then
17070   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKGHANDLER" >&5
17071 $as_echo "$PKGHANDLER" >&6; }
17072 else
17073   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17074 $as_echo "no" >&6; }
17075 fi
17076 
17077 
17078   test -n "$PKGHANDLER" && break
17079 done
17080 
17081 
17082 
17083 # Setup tools that requires more complex handling, or that is not needed by the configure script.
17084 
17085 
17086 
17087   # Publish this variable in the help.
17088 
17089 
17090   if [ -z "${MAKE+x}" ]; then
17091     # The variable is not set by user, try to locate tool using the code snippet
17092 
17093     # Try our hardest to locate a correct version of GNU make
17094     for ac_prog in gmake
17095 do
17096   # Extract the first word of "$ac_prog", so it can be a program name with args.
17097 set dummy $ac_prog; ac_word=$2
17098 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17099 $as_echo_n "checking for $ac_word... " >&6; }
17100 if ${ac_cv_path_CHECK_GMAKE+:} false; then :
17101   $as_echo_n "(cached) " >&6
17102 else
17103   case $CHECK_GMAKE in
17104   [\\/]* | ?:[\\/]*)
17105   ac_cv_path_CHECK_GMAKE="$CHECK_GMAKE" # Let the user override the test with a path.
17106   ;;
17107   *)
17108   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17109 for as_dir in $PATH
17110 do
17111   IFS=$as_save_IFS
17112   test -z "$as_dir" && as_dir=.
17113     for ac_exec_ext in '' $ac_executable_extensions; do
17114   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17115     ac_cv_path_CHECK_GMAKE="$as_dir/$ac_word$ac_exec_ext"
17116     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17117     break 2
17118   fi
17119 done
17120   done
17121 IFS=$as_save_IFS
17122 
17123   ;;
17124 esac
17125 fi
17126 CHECK_GMAKE=$ac_cv_path_CHECK_GMAKE
17127 if test -n "$CHECK_GMAKE"; then
17128   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_GMAKE" >&5
17129 $as_echo "$CHECK_GMAKE" >&6; }
17130 else
17131   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17132 $as_echo "no" >&6; }
17133 fi
17134 
17135 
17136   test -n "$CHECK_GMAKE" && break
17137 done
17138 
17139 
17140   MAKE_CANDIDATE=""$CHECK_GMAKE""
17141   DESCRIPTION="gmake in PATH"
17142 
17143   # On Cygwin, we require a newer version of make than on other platforms
17144   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17145     MAKE_VERSION_EXPR="-e 4\."
17146     MAKE_REQUIRED_VERSION="4.0"
17147    else
17148     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
17149     MAKE_REQUIRED_VERSION="3.81"
17150   fi
17151 
17152   if test "x$MAKE_CANDIDATE" != x; then
17153     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
17154 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
17155     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
17156     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
17157     if test "x$IS_GNU_MAKE" = x; then
17158       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
17159 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
17160     else
17161       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
17162       if test "x$IS_MODERN_MAKE" = x; then
17163         { $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
17164 $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;}
17165       else
17166         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
17167           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17168             MAKE_EXPECTED_ENV='cygwin'
17169           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17170             MAKE_EXPECTED_ENV='msys'
17171           else
17172             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
17173           fi
17174           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
17175           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
17176         else
17177           # Not relevant for non-Windows
17178           IS_MAKE_CORRECT_ENV=true
17179         fi
17180         if test "x$IS_MAKE_CORRECT_ENV" = x; then
17181           { $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
17182 $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;}
17183         else
17184           FOUND_MAKE=$MAKE_CANDIDATE
17185 
17186   # Only process if variable expands to non-empty
17187 
17188   if test "x$FOUND_MAKE" != x; then
17189     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17190 
17191   # First separate the path from the arguments. This will split at the first
17192   # space.
17193   complete="$FOUND_MAKE"
17194   path="${complete%% *}"
17195   tmp="$complete EOL"
17196   arguments="${tmp#* }"
17197 
17198   # Input might be given as Windows format, start by converting to
17199   # unix format.
17200   new_path=`$CYGPATH -u "$path"`
17201 
17202   # Now try to locate executable using which
17203   new_path=`$WHICH "$new_path" 2> /dev/null`
17204   # bat and cmd files are not always considered executable in cygwin causing which
17205   # to not find them
17206   if test "x$new_path" = x \
17207       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17208       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17209     new_path=`$CYGPATH -u "$path"`
17210   fi
17211   if test "x$new_path" = x; then
17212     # Oops. Which didn't find the executable.
17213     # The splitting of arguments from the executable at a space might have been incorrect,
17214     # since paths with space are more likely in Windows. Give it another try with the whole
17215     # argument.
17216     path="$complete"
17217     arguments="EOL"
17218     new_path=`$CYGPATH -u "$path"`
17219     new_path=`$WHICH "$new_path" 2> /dev/null`
17220     # bat and cmd files are not always considered executable in cygwin causing which
17221     # to not find them
17222     if test "x$new_path" = x \
17223         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17224         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17225       new_path=`$CYGPATH -u "$path"`
17226     fi
17227     if test "x$new_path" = x; then
17228       # It's still not found. Now this is an unrecoverable error.
17229       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17230 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17231       has_space=`$ECHO "$complete" | $GREP " "`
17232       if test "x$has_space" != x; then
17233         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
17234 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
17235       fi
17236       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17237     fi
17238   fi
17239 
17240   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
17241   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
17242   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
17243   # "foo.exe" is OK but "foo" is an error.
17244   #
17245   # This test is therefore slightly more accurate than "test -f" to check for file presence.
17246   # It is also a way to make sure we got the proper file name for the real test later on.
17247   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
17248   if test "x$test_shortpath" = x; then
17249     # Short path failed, file does not exist as specified.
17250     # Try adding .exe or .cmd
17251     if test -f "${new_path}.exe"; then
17252       input_to_shortpath="${new_path}.exe"
17253     elif test -f "${new_path}.cmd"; then
17254       input_to_shortpath="${new_path}.cmd"
17255     else
17256       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
17257 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
17258       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
17259 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
17260       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17261     fi
17262   else
17263     input_to_shortpath="$new_path"
17264   fi
17265 
17266   # Call helper function which possibly converts this using DOS-style short mode.
17267   # If so, the updated path is stored in $new_path.
17268   new_path="$input_to_shortpath"
17269 
17270   input_path="$input_to_shortpath"
17271   # Check if we need to convert this using DOS-style short mode. If the path
17272   # contains just simple characters, use it. Otherwise (spaces, weird characters),
17273   # take no chances and rewrite it.
17274   # Note: m4 eats our [], so we need to use [ and ] instead.
17275   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
17276   if test "x$has_forbidden_chars" != x; then
17277     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
17278     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
17279     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
17280     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
17281       # Going to short mode and back again did indeed matter. Since short mode is
17282       # case insensitive, let's make it lowercase to improve readability.
17283       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
17284       # Now convert it back to Unix-style (cygpath)
17285       input_path=`$CYGPATH -u "$shortmode_path"`
17286       new_path="$input_path"
17287     fi
17288   fi
17289 
17290   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
17291   if test "x$test_cygdrive_prefix" = x; then
17292     # As a simple fix, exclude /usr/bin since it's not a real path.
17293     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
17294       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
17295       # a path prefixed by /cygdrive for fixpath to work.
17296       new_path="$CYGWIN_ROOT_PATH$input_path"
17297     fi
17298   fi
17299 
17300   # remove trailing .exe if any
17301   new_path="${new_path/%.exe/}"
17302 
17303     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17304 
17305   # First separate the path from the arguments. This will split at the first
17306   # space.
17307   complete="$FOUND_MAKE"
17308   path="${complete%% *}"
17309   tmp="$complete EOL"
17310   arguments="${tmp#* }"
17311 
17312   # Input might be given as Windows format, start by converting to
17313   # unix format.
17314   new_path="$path"
17315 
17316   windows_path="$new_path"
17317   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17318     unix_path=`$CYGPATH -u "$windows_path"`
17319     new_path="$unix_path"
17320   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17321     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17322     new_path="$unix_path"
17323   fi
17324 
17325 
17326   # Now try to locate executable using which
17327   new_path=`$WHICH "$new_path" 2> /dev/null`
17328 
17329   if test "x$new_path" = x; then
17330     # Oops. Which didn't find the executable.
17331     # The splitting of arguments from the executable at a space might have been incorrect,
17332     # since paths with space are more likely in Windows. Give it another try with the whole
17333     # argument.
17334     path="$complete"
17335     arguments="EOL"
17336     new_path="$path"
17337 
17338   windows_path="$new_path"
17339   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17340     unix_path=`$CYGPATH -u "$windows_path"`
17341     new_path="$unix_path"
17342   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17343     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17344     new_path="$unix_path"
17345   fi
17346 
17347 
17348     new_path=`$WHICH "$new_path" 2> /dev/null`
17349     # bat and cmd files are not always considered executable in MSYS causing which
17350     # to not find them
17351     if test "x$new_path" = x \
17352         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17353         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17354       new_path="$path"
17355 
17356   windows_path="$new_path"
17357   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17358     unix_path=`$CYGPATH -u "$windows_path"`
17359     new_path="$unix_path"
17360   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17361     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17362     new_path="$unix_path"
17363   fi
17364 
17365     fi
17366 
17367     if test "x$new_path" = x; then
17368       # It's still not found. Now this is an unrecoverable error.
17369       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17370 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17371       has_space=`$ECHO "$complete" | $GREP " "`
17372       if test "x$has_space" != x; then
17373         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
17374 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
17375       fi
17376       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17377     fi
17378   fi
17379 
17380   # Now new_path has a complete unix path to the binary
17381   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
17382     # Keep paths in /bin as-is, but remove trailing .exe if any
17383     new_path="${new_path/%.exe/}"
17384     # Do not save /bin paths to all_fixpath_prefixes!
17385   else
17386     # Not in mixed or Windows style, start by that.
17387     new_path=`cmd //c echo $new_path`
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     # Output is in $new_path
17401 
17402   windows_path="$new_path"
17403   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17404     unix_path=`$CYGPATH -u "$windows_path"`
17405     new_path="$unix_path"
17406   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17407     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17408     new_path="$unix_path"
17409   fi
17410 
17411     # remove trailing .exe if any
17412     new_path="${new_path/%.exe/}"
17413 
17414     # Save the first 10 bytes of this path to the storage, so fixpath can work.
17415     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
17416   fi
17417 
17418     else
17419       # We're on a unix platform. Hooray! :)
17420       # First separate the path from the arguments. This will split at the first
17421       # space.
17422       complete="$FOUND_MAKE"
17423       path="${complete%% *}"
17424       tmp="$complete EOL"
17425       arguments="${tmp#* }"
17426 
17427       # Cannot rely on the command "which" here since it doesn't always work.
17428       is_absolute_path=`$ECHO "$path" | $GREP ^/`
17429       if test -z "$is_absolute_path"; then
17430         # Path to executable is not absolute. Find it.
17431         IFS_save="$IFS"
17432         IFS=:
17433         for p in $PATH; do
17434           if test -f "$p/$path" && test -x "$p/$path"; then
17435             new_path="$p/$path"
17436             break
17437           fi
17438         done
17439         IFS="$IFS_save"
17440       else
17441         # This is an absolute path, we can use it without further modifications.
17442         new_path="$path"
17443       fi
17444 
17445       if test "x$new_path" = x; then
17446         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17447 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17448         has_space=`$ECHO "$complete" | $GREP " "`
17449         if test "x$has_space" != x; then
17450           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
17451 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
17452         fi
17453         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17454       fi
17455     fi
17456 
17457     # Now join together the path and the arguments once again
17458     if test "x$arguments" != xEOL; then
17459       new_complete="$new_path ${arguments% *}"
17460     else
17461       new_complete="$new_path"
17462     fi
17463 
17464     if test "x$complete" != "x$new_complete"; then
17465       FOUND_MAKE="$new_complete"
17466       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
17467 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
17468     fi
17469   fi
17470 
17471         fi
17472       fi
17473     fi
17474   fi
17475 
17476 
17477     if test "x$FOUND_MAKE" = x; then
17478       for ac_prog in make
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_path_CHECK_MAKE+:} false; then :
17485   $as_echo_n "(cached) " >&6
17486 else
17487   case $CHECK_MAKE in
17488   [\\/]* | ?:[\\/]*)
17489   ac_cv_path_CHECK_MAKE="$CHECK_MAKE" # Let the user override the test with a path.
17490   ;;
17491   *)
17492   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17493 for as_dir in $PATH
17494 do
17495   IFS=$as_save_IFS
17496   test -z "$as_dir" && as_dir=.
17497     for ac_exec_ext in '' $ac_executable_extensions; do
17498   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17499     ac_cv_path_CHECK_MAKE="$as_dir/$ac_word$ac_exec_ext"
17500     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17501     break 2
17502   fi
17503 done
17504   done
17505 IFS=$as_save_IFS
17506 
17507   ;;
17508 esac
17509 fi
17510 CHECK_MAKE=$ac_cv_path_CHECK_MAKE
17511 if test -n "$CHECK_MAKE"; then
17512   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_MAKE" >&5
17513 $as_echo "$CHECK_MAKE" >&6; }
17514 else
17515   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17516 $as_echo "no" >&6; }
17517 fi
17518 
17519 
17520   test -n "$CHECK_MAKE" && break
17521 done
17522 
17523 
17524   MAKE_CANDIDATE=""$CHECK_MAKE""
17525   DESCRIPTION="make in PATH"
17526 
17527   # On Cygwin, we require a newer version of make than on other platforms
17528   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17529     MAKE_VERSION_EXPR="-e 4\."
17530     MAKE_REQUIRED_VERSION="4.0"
17531    else
17532     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
17533     MAKE_REQUIRED_VERSION="3.81"
17534   fi
17535 
17536   if test "x$MAKE_CANDIDATE" != x; then
17537     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
17538 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
17539     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
17540     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
17541     if test "x$IS_GNU_MAKE" = x; then
17542       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
17543 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
17544     else
17545       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
17546       if test "x$IS_MODERN_MAKE" = x; then
17547         { $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
17548 $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;}
17549       else
17550         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
17551           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17552             MAKE_EXPECTED_ENV='cygwin'
17553           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17554             MAKE_EXPECTED_ENV='msys'
17555           else
17556             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
17557           fi
17558           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
17559           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
17560         else
17561           # Not relevant for non-Windows
17562           IS_MAKE_CORRECT_ENV=true
17563         fi
17564         if test "x$IS_MAKE_CORRECT_ENV" = x; then
17565           { $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
17566 $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;}
17567         else
17568           FOUND_MAKE=$MAKE_CANDIDATE
17569 
17570   # Only process if variable expands to non-empty
17571 
17572   if test "x$FOUND_MAKE" != x; then
17573     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17574 
17575   # First separate the path from the arguments. This will split at the first
17576   # space.
17577   complete="$FOUND_MAKE"
17578   path="${complete%% *}"
17579   tmp="$complete EOL"
17580   arguments="${tmp#* }"
17581 
17582   # Input might be given as Windows format, start by converting to
17583   # unix format.
17584   new_path=`$CYGPATH -u "$path"`
17585 
17586   # Now try to locate executable using which
17587   new_path=`$WHICH "$new_path" 2> /dev/null`
17588   # bat and cmd files are not always considered executable in cygwin causing which
17589   # to not find them
17590   if test "x$new_path" = x \
17591       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17592       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17593     new_path=`$CYGPATH -u "$path"`
17594   fi
17595   if test "x$new_path" = x; then
17596     # Oops. Which didn't find the executable.
17597     # The splitting of arguments from the executable at a space might have been incorrect,
17598     # since paths with space are more likely in Windows. Give it another try with the whole
17599     # argument.
17600     path="$complete"
17601     arguments="EOL"
17602     new_path=`$CYGPATH -u "$path"`
17603     new_path=`$WHICH "$new_path" 2> /dev/null`
17604     # bat and cmd files are not always considered executable in cygwin causing which
17605     # to not find them
17606     if test "x$new_path" = x \
17607         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17608         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17609       new_path=`$CYGPATH -u "$path"`
17610     fi
17611     if test "x$new_path" = x; then
17612       # It's still not found. Now this is an unrecoverable error.
17613       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17614 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17615       has_space=`$ECHO "$complete" | $GREP " "`
17616       if test "x$has_space" != x; then
17617         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
17618 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
17619       fi
17620       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17621     fi
17622   fi
17623 
17624   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
17625   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
17626   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
17627   # "foo.exe" is OK but "foo" is an error.
17628   #
17629   # This test is therefore slightly more accurate than "test -f" to check for file presence.
17630   # It is also a way to make sure we got the proper file name for the real test later on.
17631   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
17632   if test "x$test_shortpath" = x; then
17633     # Short path failed, file does not exist as specified.
17634     # Try adding .exe or .cmd
17635     if test -f "${new_path}.exe"; then
17636       input_to_shortpath="${new_path}.exe"
17637     elif test -f "${new_path}.cmd"; then
17638       input_to_shortpath="${new_path}.cmd"
17639     else
17640       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
17641 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
17642       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
17643 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
17644       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17645     fi
17646   else
17647     input_to_shortpath="$new_path"
17648   fi
17649 
17650   # Call helper function which possibly converts this using DOS-style short mode.
17651   # If so, the updated path is stored in $new_path.
17652   new_path="$input_to_shortpath"
17653 
17654   input_path="$input_to_shortpath"
17655   # Check if we need to convert this using DOS-style short mode. If the path
17656   # contains just simple characters, use it. Otherwise (spaces, weird characters),
17657   # take no chances and rewrite it.
17658   # Note: m4 eats our [], so we need to use [ and ] instead.
17659   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
17660   if test "x$has_forbidden_chars" != x; then
17661     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
17662     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
17663     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
17664     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
17665       # Going to short mode and back again did indeed matter. Since short mode is
17666       # case insensitive, let's make it lowercase to improve readability.
17667       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
17668       # Now convert it back to Unix-style (cygpath)
17669       input_path=`$CYGPATH -u "$shortmode_path"`
17670       new_path="$input_path"
17671     fi
17672   fi
17673 
17674   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
17675   if test "x$test_cygdrive_prefix" = x; then
17676     # As a simple fix, exclude /usr/bin since it's not a real path.
17677     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
17678       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
17679       # a path prefixed by /cygdrive for fixpath to work.
17680       new_path="$CYGWIN_ROOT_PATH$input_path"
17681     fi
17682   fi
17683 
17684   # remove trailing .exe if any
17685   new_path="${new_path/%.exe/}"
17686 
17687     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17688 
17689   # First separate the path from the arguments. This will split at the first
17690   # space.
17691   complete="$FOUND_MAKE"
17692   path="${complete%% *}"
17693   tmp="$complete EOL"
17694   arguments="${tmp#* }"
17695 
17696   # Input might be given as Windows format, start by converting to
17697   # unix format.
17698   new_path="$path"
17699 
17700   windows_path="$new_path"
17701   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17702     unix_path=`$CYGPATH -u "$windows_path"`
17703     new_path="$unix_path"
17704   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17705     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17706     new_path="$unix_path"
17707   fi
17708 
17709 
17710   # Now try to locate executable using which
17711   new_path=`$WHICH "$new_path" 2> /dev/null`
17712 
17713   if test "x$new_path" = x; then
17714     # Oops. Which didn't find the executable.
17715     # The splitting of arguments from the executable at a space might have been incorrect,
17716     # since paths with space are more likely in Windows. Give it another try with the whole
17717     # argument.
17718     path="$complete"
17719     arguments="EOL"
17720     new_path="$path"
17721 
17722   windows_path="$new_path"
17723   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17724     unix_path=`$CYGPATH -u "$windows_path"`
17725     new_path="$unix_path"
17726   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17727     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17728     new_path="$unix_path"
17729   fi
17730 
17731 
17732     new_path=`$WHICH "$new_path" 2> /dev/null`
17733     # bat and cmd files are not always considered executable in MSYS causing which
17734     # to not find them
17735     if test "x$new_path" = x \
17736         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17737         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17738       new_path="$path"
17739 
17740   windows_path="$new_path"
17741   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17742     unix_path=`$CYGPATH -u "$windows_path"`
17743     new_path="$unix_path"
17744   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17745     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17746     new_path="$unix_path"
17747   fi
17748 
17749     fi
17750 
17751     if test "x$new_path" = x; then
17752       # It's still not found. Now this is an unrecoverable error.
17753       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17754 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17755       has_space=`$ECHO "$complete" | $GREP " "`
17756       if test "x$has_space" != x; then
17757         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
17758 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
17759       fi
17760       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17761     fi
17762   fi
17763 
17764   # Now new_path has a complete unix path to the binary
17765   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
17766     # Keep paths in /bin as-is, but remove trailing .exe if any
17767     new_path="${new_path/%.exe/}"
17768     # Do not save /bin paths to all_fixpath_prefixes!
17769   else
17770     # Not in mixed or Windows style, start by that.
17771     new_path=`cmd //c echo $new_path`
17772 
17773   input_path="$new_path"
17774   # Check if we need to convert this using DOS-style short mode. If the path
17775   # contains just simple characters, use it. Otherwise (spaces, weird characters),
17776   # take no chances and rewrite it.
17777   # Note: m4 eats our [], so we need to use [ and ] instead.
17778   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
17779   if test "x$has_forbidden_chars" != x; then
17780     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
17781     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
17782   fi
17783 
17784     # Output is in $new_path
17785 
17786   windows_path="$new_path"
17787   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17788     unix_path=`$CYGPATH -u "$windows_path"`
17789     new_path="$unix_path"
17790   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17791     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17792     new_path="$unix_path"
17793   fi
17794 
17795     # remove trailing .exe if any
17796     new_path="${new_path/%.exe/}"
17797 
17798     # Save the first 10 bytes of this path to the storage, so fixpath can work.
17799     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
17800   fi
17801 
17802     else
17803       # We're on a unix platform. Hooray! :)
17804       # First separate the path from the arguments. This will split at the first
17805       # space.
17806       complete="$FOUND_MAKE"
17807       path="${complete%% *}"
17808       tmp="$complete EOL"
17809       arguments="${tmp#* }"
17810 
17811       # Cannot rely on the command "which" here since it doesn't always work.
17812       is_absolute_path=`$ECHO "$path" | $GREP ^/`
17813       if test -z "$is_absolute_path"; then
17814         # Path to executable is not absolute. Find it.
17815         IFS_save="$IFS"
17816         IFS=:
17817         for p in $PATH; do
17818           if test -f "$p/$path" && test -x "$p/$path"; then
17819             new_path="$p/$path"
17820             break
17821           fi
17822         done
17823         IFS="$IFS_save"
17824       else
17825         # This is an absolute path, we can use it without further modifications.
17826         new_path="$path"
17827       fi
17828 
17829       if test "x$new_path" = x; then
17830         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17831 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17832         has_space=`$ECHO "$complete" | $GREP " "`
17833         if test "x$has_space" != x; then
17834           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
17835 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
17836         fi
17837         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17838       fi
17839     fi
17840 
17841     # Now join together the path and the arguments once again
17842     if test "x$arguments" != xEOL; then
17843       new_complete="$new_path ${arguments% *}"
17844     else
17845       new_complete="$new_path"
17846     fi
17847 
17848     if test "x$complete" != "x$new_complete"; then
17849       FOUND_MAKE="$new_complete"
17850       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
17851 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
17852     fi
17853   fi
17854 
17855         fi
17856       fi
17857     fi
17858   fi
17859 
17860     fi
17861 
17862     if test "x$FOUND_MAKE" = x; then
17863       if test "x$TOOLCHAIN_PATH" != x; then
17864         # We have a toolchain path, check that as well before giving up.
17865         OLD_PATH=$PATH
17866         PATH=$TOOLCHAIN_PATH:$PATH
17867         for ac_prog in gmake
17868 do
17869   # Extract the first word of "$ac_prog", so it can be a program name with args.
17870 set dummy $ac_prog; ac_word=$2
17871 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17872 $as_echo_n "checking for $ac_word... " >&6; }
17873 if ${ac_cv_path_CHECK_TOOLSDIR_GMAKE+:} false; then :
17874   $as_echo_n "(cached) " >&6
17875 else
17876   case $CHECK_TOOLSDIR_GMAKE in
17877   [\\/]* | ?:[\\/]*)
17878   ac_cv_path_CHECK_TOOLSDIR_GMAKE="$CHECK_TOOLSDIR_GMAKE" # Let the user override the test with a path.
17879   ;;
17880   *)
17881   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17882 for as_dir in $PATH
17883 do
17884   IFS=$as_save_IFS
17885   test -z "$as_dir" && as_dir=.
17886     for ac_exec_ext in '' $ac_executable_extensions; do
17887   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17888     ac_cv_path_CHECK_TOOLSDIR_GMAKE="$as_dir/$ac_word$ac_exec_ext"
17889     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17890     break 2
17891   fi
17892 done
17893   done
17894 IFS=$as_save_IFS
17895 
17896   ;;
17897 esac
17898 fi
17899 CHECK_TOOLSDIR_GMAKE=$ac_cv_path_CHECK_TOOLSDIR_GMAKE
17900 if test -n "$CHECK_TOOLSDIR_GMAKE"; then
17901   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_GMAKE" >&5
17902 $as_echo "$CHECK_TOOLSDIR_GMAKE" >&6; }
17903 else
17904   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17905 $as_echo "no" >&6; }
17906 fi
17907 
17908 
17909   test -n "$CHECK_TOOLSDIR_GMAKE" && break
17910 done
17911 
17912 
17913   MAKE_CANDIDATE=""$CHECK_TOOLSDIR_GMAKE""
17914   DESCRIPTION="gmake in tools-dir"
17915 
17916   # On Cygwin, we require a newer version of make than on other platforms
17917   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17918     MAKE_VERSION_EXPR="-e 4\."
17919     MAKE_REQUIRED_VERSION="4.0"
17920    else
17921     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
17922     MAKE_REQUIRED_VERSION="3.81"
17923   fi
17924 
17925   if test "x$MAKE_CANDIDATE" != x; then
17926     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
17927 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
17928     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
17929     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
17930     if test "x$IS_GNU_MAKE" = x; then
17931       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
17932 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
17933     else
17934       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
17935       if test "x$IS_MODERN_MAKE" = x; then
17936         { $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
17937 $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;}
17938       else
17939         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
17940           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17941             MAKE_EXPECTED_ENV='cygwin'
17942           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17943             MAKE_EXPECTED_ENV='msys'
17944           else
17945             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
17946           fi
17947           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
17948           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
17949         else
17950           # Not relevant for non-Windows
17951           IS_MAKE_CORRECT_ENV=true
17952         fi
17953         if test "x$IS_MAKE_CORRECT_ENV" = x; then
17954           { $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
17955 $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;}
17956         else
17957           FOUND_MAKE=$MAKE_CANDIDATE
17958 
17959   # Only process if variable expands to non-empty
17960 
17961   if test "x$FOUND_MAKE" != x; then
17962     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17963 
17964   # First separate the path from the arguments. This will split at the first
17965   # space.
17966   complete="$FOUND_MAKE"
17967   path="${complete%% *}"
17968   tmp="$complete EOL"
17969   arguments="${tmp#* }"
17970 
17971   # Input might be given as Windows format, start by converting to
17972   # unix format.
17973   new_path=`$CYGPATH -u "$path"`
17974 
17975   # Now try to locate executable using which
17976   new_path=`$WHICH "$new_path" 2> /dev/null`
17977   # bat and cmd files are not always considered executable in cygwin causing which
17978   # to not find them
17979   if test "x$new_path" = x \
17980       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17981       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17982     new_path=`$CYGPATH -u "$path"`
17983   fi
17984   if test "x$new_path" = x; then
17985     # Oops. Which didn't find the executable.
17986     # The splitting of arguments from the executable at a space might have been incorrect,
17987     # since paths with space are more likely in Windows. Give it another try with the whole
17988     # argument.
17989     path="$complete"
17990     arguments="EOL"
17991     new_path=`$CYGPATH -u "$path"`
17992     new_path=`$WHICH "$new_path" 2> /dev/null`
17993     # bat and cmd files are not always considered executable in cygwin causing which
17994     # to not find them
17995     if test "x$new_path" = x \
17996         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17997         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17998       new_path=`$CYGPATH -u "$path"`
17999     fi
18000     if test "x$new_path" = x; then
18001       # It's still not found. Now this is an unrecoverable error.
18002       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18003 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18004       has_space=`$ECHO "$complete" | $GREP " "`
18005       if test "x$has_space" != x; then
18006         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
18007 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
18008       fi
18009       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18010     fi
18011   fi
18012 
18013   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
18014   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
18015   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
18016   # "foo.exe" is OK but "foo" is an error.
18017   #
18018   # This test is therefore slightly more accurate than "test -f" to check for file presence.
18019   # It is also a way to make sure we got the proper file name for the real test later on.
18020   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
18021   if test "x$test_shortpath" = x; then
18022     # Short path failed, file does not exist as specified.
18023     # Try adding .exe or .cmd
18024     if test -f "${new_path}.exe"; then
18025       input_to_shortpath="${new_path}.exe"
18026     elif test -f "${new_path}.cmd"; then
18027       input_to_shortpath="${new_path}.cmd"
18028     else
18029       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
18030 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
18031       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
18032 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
18033       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18034     fi
18035   else
18036     input_to_shortpath="$new_path"
18037   fi
18038 
18039   # Call helper function which possibly converts this using DOS-style short mode.
18040   # If so, the updated path is stored in $new_path.
18041   new_path="$input_to_shortpath"
18042 
18043   input_path="$input_to_shortpath"
18044   # Check if we need to convert this using DOS-style short mode. If the path
18045   # contains just simple characters, use it. Otherwise (spaces, weird characters),
18046   # take no chances and rewrite it.
18047   # Note: m4 eats our [], so we need to use [ and ] instead.
18048   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
18049   if test "x$has_forbidden_chars" != x; then
18050     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
18051     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
18052     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
18053     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
18054       # Going to short mode and back again did indeed matter. Since short mode is
18055       # case insensitive, let's make it lowercase to improve readability.
18056       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
18057       # Now convert it back to Unix-style (cygpath)
18058       input_path=`$CYGPATH -u "$shortmode_path"`
18059       new_path="$input_path"
18060     fi
18061   fi
18062 
18063   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
18064   if test "x$test_cygdrive_prefix" = x; then
18065     # As a simple fix, exclude /usr/bin since it's not a real path.
18066     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
18067       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
18068       # a path prefixed by /cygdrive for fixpath to work.
18069       new_path="$CYGWIN_ROOT_PATH$input_path"
18070     fi
18071   fi
18072 
18073   # remove trailing .exe if any
18074   new_path="${new_path/%.exe/}"
18075 
18076     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18077 
18078   # First separate the path from the arguments. This will split at the first
18079   # space.
18080   complete="$FOUND_MAKE"
18081   path="${complete%% *}"
18082   tmp="$complete EOL"
18083   arguments="${tmp#* }"
18084 
18085   # Input might be given as Windows format, start by converting to
18086   # unix format.
18087   new_path="$path"
18088 
18089   windows_path="$new_path"
18090   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18091     unix_path=`$CYGPATH -u "$windows_path"`
18092     new_path="$unix_path"
18093   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18094     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18095     new_path="$unix_path"
18096   fi
18097 
18098 
18099   # Now try to locate executable using which
18100   new_path=`$WHICH "$new_path" 2> /dev/null`
18101 
18102   if test "x$new_path" = x; then
18103     # Oops. Which didn't find the executable.
18104     # The splitting of arguments from the executable at a space might have been incorrect,
18105     # since paths with space are more likely in Windows. Give it another try with the whole
18106     # argument.
18107     path="$complete"
18108     arguments="EOL"
18109     new_path="$path"
18110 
18111   windows_path="$new_path"
18112   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18113     unix_path=`$CYGPATH -u "$windows_path"`
18114     new_path="$unix_path"
18115   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18116     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18117     new_path="$unix_path"
18118   fi
18119 
18120 
18121     new_path=`$WHICH "$new_path" 2> /dev/null`
18122     # bat and cmd files are not always considered executable in MSYS causing which
18123     # to not find them
18124     if test "x$new_path" = x \
18125         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18126         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18127       new_path="$path"
18128 
18129   windows_path="$new_path"
18130   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18131     unix_path=`$CYGPATH -u "$windows_path"`
18132     new_path="$unix_path"
18133   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18134     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18135     new_path="$unix_path"
18136   fi
18137 
18138     fi
18139 
18140     if test "x$new_path" = x; then
18141       # It's still not found. Now this is an unrecoverable error.
18142       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18143 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18144       has_space=`$ECHO "$complete" | $GREP " "`
18145       if test "x$has_space" != x; then
18146         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
18147 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
18148       fi
18149       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18150     fi
18151   fi
18152 
18153   # Now new_path has a complete unix path to the binary
18154   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
18155     # Keep paths in /bin as-is, but remove trailing .exe if any
18156     new_path="${new_path/%.exe/}"
18157     # Do not save /bin paths to all_fixpath_prefixes!
18158   else
18159     # Not in mixed or Windows style, start by that.
18160     new_path=`cmd //c echo $new_path`
18161 
18162   input_path="$new_path"
18163   # Check if we need to convert this using DOS-style short mode. If the path
18164   # contains just simple characters, use it. Otherwise (spaces, weird characters),
18165   # take no chances and rewrite it.
18166   # Note: m4 eats our [], so we need to use [ and ] instead.
18167   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
18168   if test "x$has_forbidden_chars" != x; then
18169     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
18170     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
18171   fi
18172 
18173     # Output is in $new_path
18174 
18175   windows_path="$new_path"
18176   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18177     unix_path=`$CYGPATH -u "$windows_path"`
18178     new_path="$unix_path"
18179   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18180     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18181     new_path="$unix_path"
18182   fi
18183 
18184     # remove trailing .exe if any
18185     new_path="${new_path/%.exe/}"
18186 
18187     # Save the first 10 bytes of this path to the storage, so fixpath can work.
18188     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
18189   fi
18190 
18191     else
18192       # We're on a unix platform. Hooray! :)
18193       # First separate the path from the arguments. This will split at the first
18194       # space.
18195       complete="$FOUND_MAKE"
18196       path="${complete%% *}"
18197       tmp="$complete EOL"
18198       arguments="${tmp#* }"
18199 
18200       # Cannot rely on the command "which" here since it doesn't always work.
18201       is_absolute_path=`$ECHO "$path" | $GREP ^/`
18202       if test -z "$is_absolute_path"; then
18203         # Path to executable is not absolute. Find it.
18204         IFS_save="$IFS"
18205         IFS=:
18206         for p in $PATH; do
18207           if test -f "$p/$path" && test -x "$p/$path"; then
18208             new_path="$p/$path"
18209             break
18210           fi
18211         done
18212         IFS="$IFS_save"
18213       else
18214         # This is an absolute path, we can use it without further modifications.
18215         new_path="$path"
18216       fi
18217 
18218       if test "x$new_path" = x; then
18219         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18220 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18221         has_space=`$ECHO "$complete" | $GREP " "`
18222         if test "x$has_space" != x; then
18223           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
18224 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
18225         fi
18226         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18227       fi
18228     fi
18229 
18230     # Now join together the path and the arguments once again
18231     if test "x$arguments" != xEOL; then
18232       new_complete="$new_path ${arguments% *}"
18233     else
18234       new_complete="$new_path"
18235     fi
18236 
18237     if test "x$complete" != "x$new_complete"; then
18238       FOUND_MAKE="$new_complete"
18239       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
18240 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
18241     fi
18242   fi
18243 
18244         fi
18245       fi
18246     fi
18247   fi
18248 
18249         if test "x$FOUND_MAKE" = x; then
18250           for ac_prog in make
18251 do
18252   # Extract the first word of "$ac_prog", so it can be a program name with args.
18253 set dummy $ac_prog; ac_word=$2
18254 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18255 $as_echo_n "checking for $ac_word... " >&6; }
18256 if ${ac_cv_path_CHECK_TOOLSDIR_MAKE+:} false; then :
18257   $as_echo_n "(cached) " >&6
18258 else
18259   case $CHECK_TOOLSDIR_MAKE in
18260   [\\/]* | ?:[\\/]*)
18261   ac_cv_path_CHECK_TOOLSDIR_MAKE="$CHECK_TOOLSDIR_MAKE" # Let the user override the test with a path.
18262   ;;
18263   *)
18264   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18265 for as_dir in $PATH
18266 do
18267   IFS=$as_save_IFS
18268   test -z "$as_dir" && as_dir=.
18269     for ac_exec_ext in '' $ac_executable_extensions; do
18270   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18271     ac_cv_path_CHECK_TOOLSDIR_MAKE="$as_dir/$ac_word$ac_exec_ext"
18272     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18273     break 2
18274   fi
18275 done
18276   done
18277 IFS=$as_save_IFS
18278 
18279   ;;
18280 esac
18281 fi
18282 CHECK_TOOLSDIR_MAKE=$ac_cv_path_CHECK_TOOLSDIR_MAKE
18283 if test -n "$CHECK_TOOLSDIR_MAKE"; then
18284   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_MAKE" >&5
18285 $as_echo "$CHECK_TOOLSDIR_MAKE" >&6; }
18286 else
18287   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18288 $as_echo "no" >&6; }
18289 fi
18290 
18291 
18292   test -n "$CHECK_TOOLSDIR_MAKE" && break
18293 done
18294 
18295 
18296   MAKE_CANDIDATE=""$CHECK_TOOLSDIR_MAKE""
18297   DESCRIPTION="make in tools-dir"
18298 
18299   # On Cygwin, we require a newer version of make than on other platforms
18300   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18301     MAKE_VERSION_EXPR="-e 4\."
18302     MAKE_REQUIRED_VERSION="4.0"
18303    else
18304     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
18305     MAKE_REQUIRED_VERSION="3.81"
18306   fi
18307 
18308   if test "x$MAKE_CANDIDATE" != x; then
18309     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
18310 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
18311     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
18312     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
18313     if test "x$IS_GNU_MAKE" = x; then
18314       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
18315 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
18316     else
18317       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
18318       if test "x$IS_MODERN_MAKE" = x; then
18319         { $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
18320 $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;}
18321       else
18322         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
18323           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18324             MAKE_EXPECTED_ENV='cygwin'
18325           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18326             MAKE_EXPECTED_ENV='msys'
18327           else
18328             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
18329           fi
18330           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
18331           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
18332         else
18333           # Not relevant for non-Windows
18334           IS_MAKE_CORRECT_ENV=true
18335         fi
18336         if test "x$IS_MAKE_CORRECT_ENV" = x; then
18337           { $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
18338 $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;}
18339         else
18340           FOUND_MAKE=$MAKE_CANDIDATE
18341 
18342   # Only process if variable expands to non-empty
18343 
18344   if test "x$FOUND_MAKE" != x; then
18345     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18346 
18347   # First separate the path from the arguments. This will split at the first
18348   # space.
18349   complete="$FOUND_MAKE"
18350   path="${complete%% *}"
18351   tmp="$complete EOL"
18352   arguments="${tmp#* }"
18353 
18354   # Input might be given as Windows format, start by converting to
18355   # unix format.
18356   new_path=`$CYGPATH -u "$path"`
18357 
18358   # Now try to locate executable using which
18359   new_path=`$WHICH "$new_path" 2> /dev/null`
18360   # bat and cmd files are not always considered executable in cygwin causing which
18361   # to not find them
18362   if test "x$new_path" = x \
18363       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18364       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18365     new_path=`$CYGPATH -u "$path"`
18366   fi
18367   if test "x$new_path" = x; then
18368     # Oops. Which didn't find the executable.
18369     # The splitting of arguments from the executable at a space might have been incorrect,
18370     # since paths with space are more likely in Windows. Give it another try with the whole
18371     # argument.
18372     path="$complete"
18373     arguments="EOL"
18374     new_path=`$CYGPATH -u "$path"`
18375     new_path=`$WHICH "$new_path" 2> /dev/null`
18376     # bat and cmd files are not always considered executable in cygwin causing which
18377     # to not find them
18378     if test "x$new_path" = x \
18379         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18380         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18381       new_path=`$CYGPATH -u "$path"`
18382     fi
18383     if test "x$new_path" = x; then
18384       # It's still not found. Now this is an unrecoverable error.
18385       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18386 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18387       has_space=`$ECHO "$complete" | $GREP " "`
18388       if test "x$has_space" != x; then
18389         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
18390 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
18391       fi
18392       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18393     fi
18394   fi
18395 
18396   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
18397   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
18398   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
18399   # "foo.exe" is OK but "foo" is an error.
18400   #
18401   # This test is therefore slightly more accurate than "test -f" to check for file presence.
18402   # It is also a way to make sure we got the proper file name for the real test later on.
18403   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
18404   if test "x$test_shortpath" = x; then
18405     # Short path failed, file does not exist as specified.
18406     # Try adding .exe or .cmd
18407     if test -f "${new_path}.exe"; then
18408       input_to_shortpath="${new_path}.exe"
18409     elif test -f "${new_path}.cmd"; then
18410       input_to_shortpath="${new_path}.cmd"
18411     else
18412       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
18413 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
18414       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
18415 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
18416       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18417     fi
18418   else
18419     input_to_shortpath="$new_path"
18420   fi
18421 
18422   # Call helper function which possibly converts this using DOS-style short mode.
18423   # If so, the updated path is stored in $new_path.
18424   new_path="$input_to_shortpath"
18425 
18426   input_path="$input_to_shortpath"
18427   # Check if we need to convert this using DOS-style short mode. If the path
18428   # contains just simple characters, use it. Otherwise (spaces, weird characters),
18429   # take no chances and rewrite it.
18430   # Note: m4 eats our [], so we need to use [ and ] instead.
18431   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
18432   if test "x$has_forbidden_chars" != x; then
18433     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
18434     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
18435     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
18436     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
18437       # Going to short mode and back again did indeed matter. Since short mode is
18438       # case insensitive, let's make it lowercase to improve readability.
18439       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
18440       # Now convert it back to Unix-style (cygpath)
18441       input_path=`$CYGPATH -u "$shortmode_path"`
18442       new_path="$input_path"
18443     fi
18444   fi
18445 
18446   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
18447   if test "x$test_cygdrive_prefix" = x; then
18448     # As a simple fix, exclude /usr/bin since it's not a real path.
18449     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
18450       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
18451       # a path prefixed by /cygdrive for fixpath to work.
18452       new_path="$CYGWIN_ROOT_PATH$input_path"
18453     fi
18454   fi
18455 
18456   # remove trailing .exe if any
18457   new_path="${new_path/%.exe/}"
18458 
18459     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18460 
18461   # First separate the path from the arguments. This will split at the first
18462   # space.
18463   complete="$FOUND_MAKE"
18464   path="${complete%% *}"
18465   tmp="$complete EOL"
18466   arguments="${tmp#* }"
18467 
18468   # Input might be given as Windows format, start by converting to
18469   # unix format.
18470   new_path="$path"
18471 
18472   windows_path="$new_path"
18473   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18474     unix_path=`$CYGPATH -u "$windows_path"`
18475     new_path="$unix_path"
18476   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18477     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18478     new_path="$unix_path"
18479   fi
18480 
18481 
18482   # Now try to locate executable using which
18483   new_path=`$WHICH "$new_path" 2> /dev/null`
18484 
18485   if test "x$new_path" = x; then
18486     # Oops. Which didn't find the executable.
18487     # The splitting of arguments from the executable at a space might have been incorrect,
18488     # since paths with space are more likely in Windows. Give it another try with the whole
18489     # argument.
18490     path="$complete"
18491     arguments="EOL"
18492     new_path="$path"
18493 
18494   windows_path="$new_path"
18495   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18496     unix_path=`$CYGPATH -u "$windows_path"`
18497     new_path="$unix_path"
18498   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18499     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18500     new_path="$unix_path"
18501   fi
18502 
18503 
18504     new_path=`$WHICH "$new_path" 2> /dev/null`
18505     # bat and cmd files are not always considered executable in MSYS causing which
18506     # to not find them
18507     if test "x$new_path" = x \
18508         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18509         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18510       new_path="$path"
18511 
18512   windows_path="$new_path"
18513   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18514     unix_path=`$CYGPATH -u "$windows_path"`
18515     new_path="$unix_path"
18516   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18517     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18518     new_path="$unix_path"
18519   fi
18520 
18521     fi
18522 
18523     if test "x$new_path" = x; then
18524       # It's still not found. Now this is an unrecoverable error.
18525       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18526 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18527       has_space=`$ECHO "$complete" | $GREP " "`
18528       if test "x$has_space" != x; then
18529         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
18530 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
18531       fi
18532       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18533     fi
18534   fi
18535 
18536   # Now new_path has a complete unix path to the binary
18537   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
18538     # Keep paths in /bin as-is, but remove trailing .exe if any
18539     new_path="${new_path/%.exe/}"
18540     # Do not save /bin paths to all_fixpath_prefixes!
18541   else
18542     # Not in mixed or Windows style, start by that.
18543     new_path=`cmd //c echo $new_path`
18544 
18545   input_path="$new_path"
18546   # Check if we need to convert this using DOS-style short mode. If the path
18547   # contains just simple characters, use it. Otherwise (spaces, weird characters),
18548   # take no chances and rewrite it.
18549   # Note: m4 eats our [], so we need to use [ and ] instead.
18550   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
18551   if test "x$has_forbidden_chars" != x; then
18552     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
18553     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
18554   fi
18555 
18556     # Output is in $new_path
18557 
18558   windows_path="$new_path"
18559   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18560     unix_path=`$CYGPATH -u "$windows_path"`
18561     new_path="$unix_path"
18562   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18563     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18564     new_path="$unix_path"
18565   fi
18566 
18567     # remove trailing .exe if any
18568     new_path="${new_path/%.exe/}"
18569 
18570     # Save the first 10 bytes of this path to the storage, so fixpath can work.
18571     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
18572   fi
18573 
18574     else
18575       # We're on a unix platform. Hooray! :)
18576       # First separate the path from the arguments. This will split at the first
18577       # space.
18578       complete="$FOUND_MAKE"
18579       path="${complete%% *}"
18580       tmp="$complete EOL"
18581       arguments="${tmp#* }"
18582 
18583       # Cannot rely on the command "which" here since it doesn't always work.
18584       is_absolute_path=`$ECHO "$path" | $GREP ^/`
18585       if test -z "$is_absolute_path"; then
18586         # Path to executable is not absolute. Find it.
18587         IFS_save="$IFS"
18588         IFS=:
18589         for p in $PATH; do
18590           if test -f "$p/$path" && test -x "$p/$path"; then
18591             new_path="$p/$path"
18592             break
18593           fi
18594         done
18595         IFS="$IFS_save"
18596       else
18597         # This is an absolute path, we can use it without further modifications.
18598         new_path="$path"
18599       fi
18600 
18601       if test "x$new_path" = x; then
18602         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18603 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18604         has_space=`$ECHO "$complete" | $GREP " "`
18605         if test "x$has_space" != x; then
18606           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
18607 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
18608         fi
18609         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18610       fi
18611     fi
18612 
18613     # Now join together the path and the arguments once again
18614     if test "x$arguments" != xEOL; then
18615       new_complete="$new_path ${arguments% *}"
18616     else
18617       new_complete="$new_path"
18618     fi
18619 
18620     if test "x$complete" != "x$new_complete"; then
18621       FOUND_MAKE="$new_complete"
18622       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
18623 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
18624     fi
18625   fi
18626 
18627         fi
18628       fi
18629     fi
18630   fi
18631 
18632         fi
18633         PATH=$OLD_PATH
18634       fi
18635     fi
18636 
18637     if test "x$FOUND_MAKE" = x; then
18638       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
18639     fi
18640 
18641   else
18642     # The variable is set, but is it from the command line or the environment?
18643 
18644     # Try to remove the string !MAKE! from our list.
18645     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MAKE!/}
18646     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18647       # If it failed, the variable was not from the command line. Ignore it,
18648       # but warn the user (except for BASH, which is always set by the calling BASH).
18649       if test "xMAKE" != xBASH; then
18650         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MAKE from the environment. Use command line variables instead." >&5
18651 $as_echo "$as_me: WARNING: Ignoring value of MAKE from the environment. Use command line variables instead." >&2;}
18652       fi
18653       # Try to locate tool using the code snippet
18654 
18655     # Try our hardest to locate a correct version of GNU make
18656     for ac_prog in gmake
18657 do
18658   # Extract the first word of "$ac_prog", so it can be a program name with args.
18659 set dummy $ac_prog; ac_word=$2
18660 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18661 $as_echo_n "checking for $ac_word... " >&6; }
18662 if ${ac_cv_path_CHECK_GMAKE+:} false; then :
18663   $as_echo_n "(cached) " >&6
18664 else
18665   case $CHECK_GMAKE in
18666   [\\/]* | ?:[\\/]*)
18667   ac_cv_path_CHECK_GMAKE="$CHECK_GMAKE" # Let the user override the test with a path.
18668   ;;
18669   *)
18670   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18671 for as_dir in $PATH
18672 do
18673   IFS=$as_save_IFS
18674   test -z "$as_dir" && as_dir=.
18675     for ac_exec_ext in '' $ac_executable_extensions; do
18676   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18677     ac_cv_path_CHECK_GMAKE="$as_dir/$ac_word$ac_exec_ext"
18678     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18679     break 2
18680   fi
18681 done
18682   done
18683 IFS=$as_save_IFS
18684 
18685   ;;
18686 esac
18687 fi
18688 CHECK_GMAKE=$ac_cv_path_CHECK_GMAKE
18689 if test -n "$CHECK_GMAKE"; then
18690   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_GMAKE" >&5
18691 $as_echo "$CHECK_GMAKE" >&6; }
18692 else
18693   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18694 $as_echo "no" >&6; }
18695 fi
18696 
18697 
18698   test -n "$CHECK_GMAKE" && break
18699 done
18700 
18701 
18702   MAKE_CANDIDATE=""$CHECK_GMAKE""
18703   DESCRIPTION="gmake in PATH"
18704 
18705   # On Cygwin, we require a newer version of make than on other platforms
18706   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18707     MAKE_VERSION_EXPR="-e 4\."
18708     MAKE_REQUIRED_VERSION="4.0"
18709    else
18710     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
18711     MAKE_REQUIRED_VERSION="3.81"
18712   fi
18713 
18714   if test "x$MAKE_CANDIDATE" != x; then
18715     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
18716 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
18717     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
18718     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
18719     if test "x$IS_GNU_MAKE" = x; then
18720       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
18721 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
18722     else
18723       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
18724       if test "x$IS_MODERN_MAKE" = x; then
18725         { $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
18726 $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;}
18727       else
18728         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
18729           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18730             MAKE_EXPECTED_ENV='cygwin'
18731           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18732             MAKE_EXPECTED_ENV='msys'
18733           else
18734             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
18735           fi
18736           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
18737           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
18738         else
18739           # Not relevant for non-Windows
18740           IS_MAKE_CORRECT_ENV=true
18741         fi
18742         if test "x$IS_MAKE_CORRECT_ENV" = x; then
18743           { $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
18744 $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;}
18745         else
18746           FOUND_MAKE=$MAKE_CANDIDATE
18747 
18748   # Only process if variable expands to non-empty
18749 
18750   if test "x$FOUND_MAKE" != x; then
18751     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18752 
18753   # First separate the path from the arguments. This will split at the first
18754   # space.
18755   complete="$FOUND_MAKE"
18756   path="${complete%% *}"
18757   tmp="$complete EOL"
18758   arguments="${tmp#* }"
18759 
18760   # Input might be given as Windows format, start by converting to
18761   # unix format.
18762   new_path=`$CYGPATH -u "$path"`
18763 
18764   # Now try to locate executable using which
18765   new_path=`$WHICH "$new_path" 2> /dev/null`
18766   # bat and cmd files are not always considered executable in cygwin causing which
18767   # to not find them
18768   if test "x$new_path" = x \
18769       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18770       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18771     new_path=`$CYGPATH -u "$path"`
18772   fi
18773   if test "x$new_path" = x; then
18774     # Oops. Which didn't find the executable.
18775     # The splitting of arguments from the executable at a space might have been incorrect,
18776     # since paths with space are more likely in Windows. Give it another try with the whole
18777     # argument.
18778     path="$complete"
18779     arguments="EOL"
18780     new_path=`$CYGPATH -u "$path"`
18781     new_path=`$WHICH "$new_path" 2> /dev/null`
18782     # bat and cmd files are not always considered executable in cygwin causing which
18783     # to not find them
18784     if test "x$new_path" = x \
18785         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18786         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18787       new_path=`$CYGPATH -u "$path"`
18788     fi
18789     if test "x$new_path" = x; then
18790       # It's still not found. Now this is an unrecoverable error.
18791       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18792 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18793       has_space=`$ECHO "$complete" | $GREP " "`
18794       if test "x$has_space" != x; then
18795         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
18796 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
18797       fi
18798       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18799     fi
18800   fi
18801 
18802   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
18803   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
18804   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
18805   # "foo.exe" is OK but "foo" is an error.
18806   #
18807   # This test is therefore slightly more accurate than "test -f" to check for file presence.
18808   # It is also a way to make sure we got the proper file name for the real test later on.
18809   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
18810   if test "x$test_shortpath" = x; then
18811     # Short path failed, file does not exist as specified.
18812     # Try adding .exe or .cmd
18813     if test -f "${new_path}.exe"; then
18814       input_to_shortpath="${new_path}.exe"
18815     elif test -f "${new_path}.cmd"; then
18816       input_to_shortpath="${new_path}.cmd"
18817     else
18818       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
18819 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
18820       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
18821 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
18822       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18823     fi
18824   else
18825     input_to_shortpath="$new_path"
18826   fi
18827 
18828   # Call helper function which possibly converts this using DOS-style short mode.
18829   # If so, the updated path is stored in $new_path.
18830   new_path="$input_to_shortpath"
18831 
18832   input_path="$input_to_shortpath"
18833   # Check if we need to convert this using DOS-style short mode. If the path
18834   # contains just simple characters, use it. Otherwise (spaces, weird characters),
18835   # take no chances and rewrite it.
18836   # Note: m4 eats our [], so we need to use [ and ] instead.
18837   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
18838   if test "x$has_forbidden_chars" != x; then
18839     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
18840     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
18841     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
18842     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
18843       # Going to short mode and back again did indeed matter. Since short mode is
18844       # case insensitive, let's make it lowercase to improve readability.
18845       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
18846       # Now convert it back to Unix-style (cygpath)
18847       input_path=`$CYGPATH -u "$shortmode_path"`
18848       new_path="$input_path"
18849     fi
18850   fi
18851 
18852   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
18853   if test "x$test_cygdrive_prefix" = x; then
18854     # As a simple fix, exclude /usr/bin since it's not a real path.
18855     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
18856       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
18857       # a path prefixed by /cygdrive for fixpath to work.
18858       new_path="$CYGWIN_ROOT_PATH$input_path"
18859     fi
18860   fi
18861 
18862   # remove trailing .exe if any
18863   new_path="${new_path/%.exe/}"
18864 
18865     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18866 
18867   # First separate the path from the arguments. This will split at the first
18868   # space.
18869   complete="$FOUND_MAKE"
18870   path="${complete%% *}"
18871   tmp="$complete EOL"
18872   arguments="${tmp#* }"
18873 
18874   # Input might be given as Windows format, start by converting to
18875   # unix format.
18876   new_path="$path"
18877 
18878   windows_path="$new_path"
18879   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18880     unix_path=`$CYGPATH -u "$windows_path"`
18881     new_path="$unix_path"
18882   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18883     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18884     new_path="$unix_path"
18885   fi
18886 
18887 
18888   # Now try to locate executable using which
18889   new_path=`$WHICH "$new_path" 2> /dev/null`
18890 
18891   if test "x$new_path" = x; then
18892     # Oops. Which didn't find the executable.
18893     # The splitting of arguments from the executable at a space might have been incorrect,
18894     # since paths with space are more likely in Windows. Give it another try with the whole
18895     # argument.
18896     path="$complete"
18897     arguments="EOL"
18898     new_path="$path"
18899 
18900   windows_path="$new_path"
18901   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18902     unix_path=`$CYGPATH -u "$windows_path"`
18903     new_path="$unix_path"
18904   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18905     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18906     new_path="$unix_path"
18907   fi
18908 
18909 
18910     new_path=`$WHICH "$new_path" 2> /dev/null`
18911     # bat and cmd files are not always considered executable in MSYS causing which
18912     # to not find them
18913     if test "x$new_path" = x \
18914         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18915         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18916       new_path="$path"
18917 
18918   windows_path="$new_path"
18919   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18920     unix_path=`$CYGPATH -u "$windows_path"`
18921     new_path="$unix_path"
18922   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18923     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18924     new_path="$unix_path"
18925   fi
18926 
18927     fi
18928 
18929     if test "x$new_path" = x; then
18930       # It's still not found. Now this is an unrecoverable error.
18931       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18932 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18933       has_space=`$ECHO "$complete" | $GREP " "`
18934       if test "x$has_space" != x; then
18935         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
18936 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
18937       fi
18938       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18939     fi
18940   fi
18941 
18942   # Now new_path has a complete unix path to the binary
18943   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
18944     # Keep paths in /bin as-is, but remove trailing .exe if any
18945     new_path="${new_path/%.exe/}"
18946     # Do not save /bin paths to all_fixpath_prefixes!
18947   else
18948     # Not in mixed or Windows style, start by that.
18949     new_path=`cmd //c echo $new_path`
18950 
18951   input_path="$new_path"
18952   # Check if we need to convert this using DOS-style short mode. If the path
18953   # contains just simple characters, use it. Otherwise (spaces, weird characters),
18954   # take no chances and rewrite it.
18955   # Note: m4 eats our [], so we need to use [ and ] instead.
18956   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
18957   if test "x$has_forbidden_chars" != x; then
18958     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
18959     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
18960   fi
18961 
18962     # Output is in $new_path
18963 
18964   windows_path="$new_path"
18965   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18966     unix_path=`$CYGPATH -u "$windows_path"`
18967     new_path="$unix_path"
18968   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18969     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18970     new_path="$unix_path"
18971   fi
18972 
18973     # remove trailing .exe if any
18974     new_path="${new_path/%.exe/}"
18975 
18976     # Save the first 10 bytes of this path to the storage, so fixpath can work.
18977     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
18978   fi
18979 
18980     else
18981       # We're on a unix platform. Hooray! :)
18982       # First separate the path from the arguments. This will split at the first
18983       # space.
18984       complete="$FOUND_MAKE"
18985       path="${complete%% *}"
18986       tmp="$complete EOL"
18987       arguments="${tmp#* }"
18988 
18989       # Cannot rely on the command "which" here since it doesn't always work.
18990       is_absolute_path=`$ECHO "$path" | $GREP ^/`
18991       if test -z "$is_absolute_path"; then
18992         # Path to executable is not absolute. Find it.
18993         IFS_save="$IFS"
18994         IFS=:
18995         for p in $PATH; do
18996           if test -f "$p/$path" && test -x "$p/$path"; then
18997             new_path="$p/$path"
18998             break
18999           fi
19000         done
19001         IFS="$IFS_save"
19002       else
19003         # This is an absolute path, we can use it without further modifications.
19004         new_path="$path"
19005       fi
19006 
19007       if test "x$new_path" = x; then
19008         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19009 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19010         has_space=`$ECHO "$complete" | $GREP " "`
19011         if test "x$has_space" != x; then
19012           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
19013 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
19014         fi
19015         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19016       fi
19017     fi
19018 
19019     # Now join together the path and the arguments once again
19020     if test "x$arguments" != xEOL; then
19021       new_complete="$new_path ${arguments% *}"
19022     else
19023       new_complete="$new_path"
19024     fi
19025 
19026     if test "x$complete" != "x$new_complete"; then
19027       FOUND_MAKE="$new_complete"
19028       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
19029 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
19030     fi
19031   fi
19032 
19033         fi
19034       fi
19035     fi
19036   fi
19037 
19038 
19039     if test "x$FOUND_MAKE" = x; then
19040       for ac_prog in make
19041 do
19042   # Extract the first word of "$ac_prog", so it can be a program name with args.
19043 set dummy $ac_prog; ac_word=$2
19044 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19045 $as_echo_n "checking for $ac_word... " >&6; }
19046 if ${ac_cv_path_CHECK_MAKE+:} false; then :
19047   $as_echo_n "(cached) " >&6
19048 else
19049   case $CHECK_MAKE in
19050   [\\/]* | ?:[\\/]*)
19051   ac_cv_path_CHECK_MAKE="$CHECK_MAKE" # Let the user override the test with a path.
19052   ;;
19053   *)
19054   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19055 for as_dir in $PATH
19056 do
19057   IFS=$as_save_IFS
19058   test -z "$as_dir" && as_dir=.
19059     for ac_exec_ext in '' $ac_executable_extensions; do
19060   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19061     ac_cv_path_CHECK_MAKE="$as_dir/$ac_word$ac_exec_ext"
19062     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19063     break 2
19064   fi
19065 done
19066   done
19067 IFS=$as_save_IFS
19068 
19069   ;;
19070 esac
19071 fi
19072 CHECK_MAKE=$ac_cv_path_CHECK_MAKE
19073 if test -n "$CHECK_MAKE"; then
19074   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_MAKE" >&5
19075 $as_echo "$CHECK_MAKE" >&6; }
19076 else
19077   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19078 $as_echo "no" >&6; }
19079 fi
19080 
19081 
19082   test -n "$CHECK_MAKE" && break
19083 done
19084 
19085 
19086   MAKE_CANDIDATE=""$CHECK_MAKE""
19087   DESCRIPTION="make in PATH"
19088 
19089   # On Cygwin, we require a newer version of make than on other platforms
19090   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19091     MAKE_VERSION_EXPR="-e 4\."
19092     MAKE_REQUIRED_VERSION="4.0"
19093    else
19094     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
19095     MAKE_REQUIRED_VERSION="3.81"
19096   fi
19097 
19098   if test "x$MAKE_CANDIDATE" != x; then
19099     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
19100 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
19101     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
19102     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
19103     if test "x$IS_GNU_MAKE" = x; then
19104       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
19105 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
19106     else
19107       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
19108       if test "x$IS_MODERN_MAKE" = x; then
19109         { $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
19110 $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;}
19111       else
19112         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
19113           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19114             MAKE_EXPECTED_ENV='cygwin'
19115           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19116             MAKE_EXPECTED_ENV='msys'
19117           else
19118             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
19119           fi
19120           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
19121           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
19122         else
19123           # Not relevant for non-Windows
19124           IS_MAKE_CORRECT_ENV=true
19125         fi
19126         if test "x$IS_MAKE_CORRECT_ENV" = x; then
19127           { $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
19128 $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;}
19129         else
19130           FOUND_MAKE=$MAKE_CANDIDATE
19131 
19132   # Only process if variable expands to non-empty
19133 
19134   if test "x$FOUND_MAKE" != x; then
19135     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19136 
19137   # First separate the path from the arguments. This will split at the first
19138   # space.
19139   complete="$FOUND_MAKE"
19140   path="${complete%% *}"
19141   tmp="$complete EOL"
19142   arguments="${tmp#* }"
19143 
19144   # Input might be given as Windows format, start by converting to
19145   # unix format.
19146   new_path=`$CYGPATH -u "$path"`
19147 
19148   # Now try to locate executable using which
19149   new_path=`$WHICH "$new_path" 2> /dev/null`
19150   # bat and cmd files are not always considered executable in cygwin causing which
19151   # to not find them
19152   if test "x$new_path" = x \
19153       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19154       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19155     new_path=`$CYGPATH -u "$path"`
19156   fi
19157   if test "x$new_path" = x; then
19158     # Oops. Which didn't find the executable.
19159     # The splitting of arguments from the executable at a space might have been incorrect,
19160     # since paths with space are more likely in Windows. Give it another try with the whole
19161     # argument.
19162     path="$complete"
19163     arguments="EOL"
19164     new_path=`$CYGPATH -u "$path"`
19165     new_path=`$WHICH "$new_path" 2> /dev/null`
19166     # bat and cmd files are not always considered executable in cygwin causing which
19167     # to not find them
19168     if test "x$new_path" = x \
19169         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19170         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19171       new_path=`$CYGPATH -u "$path"`
19172     fi
19173     if test "x$new_path" = x; then
19174       # It's still not found. Now this is an unrecoverable error.
19175       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19176 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19177       has_space=`$ECHO "$complete" | $GREP " "`
19178       if test "x$has_space" != x; then
19179         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
19180 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
19181       fi
19182       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19183     fi
19184   fi
19185 
19186   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
19187   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
19188   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
19189   # "foo.exe" is OK but "foo" is an error.
19190   #
19191   # This test is therefore slightly more accurate than "test -f" to check for file presence.
19192   # It is also a way to make sure we got the proper file name for the real test later on.
19193   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
19194   if test "x$test_shortpath" = x; then
19195     # Short path failed, file does not exist as specified.
19196     # Try adding .exe or .cmd
19197     if test -f "${new_path}.exe"; then
19198       input_to_shortpath="${new_path}.exe"
19199     elif test -f "${new_path}.cmd"; then
19200       input_to_shortpath="${new_path}.cmd"
19201     else
19202       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
19203 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
19204       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
19205 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
19206       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19207     fi
19208   else
19209     input_to_shortpath="$new_path"
19210   fi
19211 
19212   # Call helper function which possibly converts this using DOS-style short mode.
19213   # If so, the updated path is stored in $new_path.
19214   new_path="$input_to_shortpath"
19215 
19216   input_path="$input_to_shortpath"
19217   # Check if we need to convert this using DOS-style short mode. If the path
19218   # contains just simple characters, use it. Otherwise (spaces, weird characters),
19219   # take no chances and rewrite it.
19220   # Note: m4 eats our [], so we need to use [ and ] instead.
19221   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
19222   if test "x$has_forbidden_chars" != x; then
19223     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
19224     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
19225     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
19226     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
19227       # Going to short mode and back again did indeed matter. Since short mode is
19228       # case insensitive, let's make it lowercase to improve readability.
19229       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
19230       # Now convert it back to Unix-style (cygpath)
19231       input_path=`$CYGPATH -u "$shortmode_path"`
19232       new_path="$input_path"
19233     fi
19234   fi
19235 
19236   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
19237   if test "x$test_cygdrive_prefix" = x; then
19238     # As a simple fix, exclude /usr/bin since it's not a real path.
19239     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
19240       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
19241       # a path prefixed by /cygdrive for fixpath to work.
19242       new_path="$CYGWIN_ROOT_PATH$input_path"
19243     fi
19244   fi
19245 
19246   # remove trailing .exe if any
19247   new_path="${new_path/%.exe/}"
19248 
19249     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19250 
19251   # First separate the path from the arguments. This will split at the first
19252   # space.
19253   complete="$FOUND_MAKE"
19254   path="${complete%% *}"
19255   tmp="$complete EOL"
19256   arguments="${tmp#* }"
19257 
19258   # Input might be given as Windows format, start by converting to
19259   # unix format.
19260   new_path="$path"
19261 
19262   windows_path="$new_path"
19263   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19264     unix_path=`$CYGPATH -u "$windows_path"`
19265     new_path="$unix_path"
19266   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19267     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19268     new_path="$unix_path"
19269   fi
19270 
19271 
19272   # Now try to locate executable using which
19273   new_path=`$WHICH "$new_path" 2> /dev/null`
19274 
19275   if test "x$new_path" = x; then
19276     # Oops. Which didn't find the executable.
19277     # The splitting of arguments from the executable at a space might have been incorrect,
19278     # since paths with space are more likely in Windows. Give it another try with the whole
19279     # argument.
19280     path="$complete"
19281     arguments="EOL"
19282     new_path="$path"
19283 
19284   windows_path="$new_path"
19285   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19286     unix_path=`$CYGPATH -u "$windows_path"`
19287     new_path="$unix_path"
19288   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19289     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19290     new_path="$unix_path"
19291   fi
19292 
19293 
19294     new_path=`$WHICH "$new_path" 2> /dev/null`
19295     # bat and cmd files are not always considered executable in MSYS causing which
19296     # to not find them
19297     if test "x$new_path" = x \
19298         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19299         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19300       new_path="$path"
19301 
19302   windows_path="$new_path"
19303   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19304     unix_path=`$CYGPATH -u "$windows_path"`
19305     new_path="$unix_path"
19306   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19307     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19308     new_path="$unix_path"
19309   fi
19310 
19311     fi
19312 
19313     if test "x$new_path" = x; then
19314       # It's still not found. Now this is an unrecoverable error.
19315       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19316 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19317       has_space=`$ECHO "$complete" | $GREP " "`
19318       if test "x$has_space" != x; then
19319         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
19320 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
19321       fi
19322       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19323     fi
19324   fi
19325 
19326   # Now new_path has a complete unix path to the binary
19327   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
19328     # Keep paths in /bin as-is, but remove trailing .exe if any
19329     new_path="${new_path/%.exe/}"
19330     # Do not save /bin paths to all_fixpath_prefixes!
19331   else
19332     # Not in mixed or Windows style, start by that.
19333     new_path=`cmd //c echo $new_path`
19334 
19335   input_path="$new_path"
19336   # Check if we need to convert this using DOS-style short mode. If the path
19337   # contains just simple characters, use it. Otherwise (spaces, weird characters),
19338   # take no chances and rewrite it.
19339   # Note: m4 eats our [], so we need to use [ and ] instead.
19340   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
19341   if test "x$has_forbidden_chars" != x; then
19342     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
19343     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
19344   fi
19345 
19346     # Output is in $new_path
19347 
19348   windows_path="$new_path"
19349   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19350     unix_path=`$CYGPATH -u "$windows_path"`
19351     new_path="$unix_path"
19352   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19353     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19354     new_path="$unix_path"
19355   fi
19356 
19357     # remove trailing .exe if any
19358     new_path="${new_path/%.exe/}"
19359 
19360     # Save the first 10 bytes of this path to the storage, so fixpath can work.
19361     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
19362   fi
19363 
19364     else
19365       # We're on a unix platform. Hooray! :)
19366       # First separate the path from the arguments. This will split at the first
19367       # space.
19368       complete="$FOUND_MAKE"
19369       path="${complete%% *}"
19370       tmp="$complete EOL"
19371       arguments="${tmp#* }"
19372 
19373       # Cannot rely on the command "which" here since it doesn't always work.
19374       is_absolute_path=`$ECHO "$path" | $GREP ^/`
19375       if test -z "$is_absolute_path"; then
19376         # Path to executable is not absolute. Find it.
19377         IFS_save="$IFS"
19378         IFS=:
19379         for p in $PATH; do
19380           if test -f "$p/$path" && test -x "$p/$path"; then
19381             new_path="$p/$path"
19382             break
19383           fi
19384         done
19385         IFS="$IFS_save"
19386       else
19387         # This is an absolute path, we can use it without further modifications.
19388         new_path="$path"
19389       fi
19390 
19391       if test "x$new_path" = x; then
19392         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19393 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19394         has_space=`$ECHO "$complete" | $GREP " "`
19395         if test "x$has_space" != x; then
19396           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
19397 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
19398         fi
19399         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19400       fi
19401     fi
19402 
19403     # Now join together the path and the arguments once again
19404     if test "x$arguments" != xEOL; then
19405       new_complete="$new_path ${arguments% *}"
19406     else
19407       new_complete="$new_path"
19408     fi
19409 
19410     if test "x$complete" != "x$new_complete"; then
19411       FOUND_MAKE="$new_complete"
19412       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
19413 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
19414     fi
19415   fi
19416 
19417         fi
19418       fi
19419     fi
19420   fi
19421 
19422     fi
19423 
19424     if test "x$FOUND_MAKE" = x; then
19425       if test "x$TOOLCHAIN_PATH" != x; then
19426         # We have a toolchain path, check that as well before giving up.
19427         OLD_PATH=$PATH
19428         PATH=$TOOLCHAIN_PATH:$PATH
19429         for ac_prog in gmake
19430 do
19431   # Extract the first word of "$ac_prog", so it can be a program name with args.
19432 set dummy $ac_prog; ac_word=$2
19433 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19434 $as_echo_n "checking for $ac_word... " >&6; }
19435 if ${ac_cv_path_CHECK_TOOLSDIR_GMAKE+:} false; then :
19436   $as_echo_n "(cached) " >&6
19437 else
19438   case $CHECK_TOOLSDIR_GMAKE in
19439   [\\/]* | ?:[\\/]*)
19440   ac_cv_path_CHECK_TOOLSDIR_GMAKE="$CHECK_TOOLSDIR_GMAKE" # Let the user override the test with a path.
19441   ;;
19442   *)
19443   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19444 for as_dir in $PATH
19445 do
19446   IFS=$as_save_IFS
19447   test -z "$as_dir" && as_dir=.
19448     for ac_exec_ext in '' $ac_executable_extensions; do
19449   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19450     ac_cv_path_CHECK_TOOLSDIR_GMAKE="$as_dir/$ac_word$ac_exec_ext"
19451     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19452     break 2
19453   fi
19454 done
19455   done
19456 IFS=$as_save_IFS
19457 
19458   ;;
19459 esac
19460 fi
19461 CHECK_TOOLSDIR_GMAKE=$ac_cv_path_CHECK_TOOLSDIR_GMAKE
19462 if test -n "$CHECK_TOOLSDIR_GMAKE"; then
19463   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_GMAKE" >&5
19464 $as_echo "$CHECK_TOOLSDIR_GMAKE" >&6; }
19465 else
19466   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19467 $as_echo "no" >&6; }
19468 fi
19469 
19470 
19471   test -n "$CHECK_TOOLSDIR_GMAKE" && break
19472 done
19473 
19474 
19475   MAKE_CANDIDATE=""$CHECK_TOOLSDIR_GMAKE""
19476   DESCRIPTION="gmake in tools-dir"
19477 
19478   # On Cygwin, we require a newer version of make than on other platforms
19479   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19480     MAKE_VERSION_EXPR="-e 4\."
19481     MAKE_REQUIRED_VERSION="4.0"
19482    else
19483     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
19484     MAKE_REQUIRED_VERSION="3.81"
19485   fi
19486 
19487   if test "x$MAKE_CANDIDATE" != x; then
19488     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
19489 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
19490     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
19491     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
19492     if test "x$IS_GNU_MAKE" = x; then
19493       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
19494 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
19495     else
19496       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
19497       if test "x$IS_MODERN_MAKE" = x; then
19498         { $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
19499 $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;}
19500       else
19501         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
19502           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19503             MAKE_EXPECTED_ENV='cygwin'
19504           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19505             MAKE_EXPECTED_ENV='msys'
19506           else
19507             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
19508           fi
19509           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
19510           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
19511         else
19512           # Not relevant for non-Windows
19513           IS_MAKE_CORRECT_ENV=true
19514         fi
19515         if test "x$IS_MAKE_CORRECT_ENV" = x; then
19516           { $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
19517 $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;}
19518         else
19519           FOUND_MAKE=$MAKE_CANDIDATE
19520 
19521   # Only process if variable expands to non-empty
19522 
19523   if test "x$FOUND_MAKE" != x; then
19524     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19525 
19526   # First separate the path from the arguments. This will split at the first
19527   # space.
19528   complete="$FOUND_MAKE"
19529   path="${complete%% *}"
19530   tmp="$complete EOL"
19531   arguments="${tmp#* }"
19532 
19533   # Input might be given as Windows format, start by converting to
19534   # unix format.
19535   new_path=`$CYGPATH -u "$path"`
19536 
19537   # Now try to locate executable using which
19538   new_path=`$WHICH "$new_path" 2> /dev/null`
19539   # bat and cmd files are not always considered executable in cygwin causing which
19540   # to not find them
19541   if test "x$new_path" = x \
19542       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19543       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19544     new_path=`$CYGPATH -u "$path"`
19545   fi
19546   if test "x$new_path" = x; then
19547     # Oops. Which didn't find the executable.
19548     # The splitting of arguments from the executable at a space might have been incorrect,
19549     # since paths with space are more likely in Windows. Give it another try with the whole
19550     # argument.
19551     path="$complete"
19552     arguments="EOL"
19553     new_path=`$CYGPATH -u "$path"`
19554     new_path=`$WHICH "$new_path" 2> /dev/null`
19555     # bat and cmd files are not always considered executable in cygwin causing which
19556     # to not find them
19557     if test "x$new_path" = x \
19558         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19559         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19560       new_path=`$CYGPATH -u "$path"`
19561     fi
19562     if test "x$new_path" = x; then
19563       # It's still not found. Now this is an unrecoverable error.
19564       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19565 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19566       has_space=`$ECHO "$complete" | $GREP " "`
19567       if test "x$has_space" != x; then
19568         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
19569 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
19570       fi
19571       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19572     fi
19573   fi
19574 
19575   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
19576   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
19577   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
19578   # "foo.exe" is OK but "foo" is an error.
19579   #
19580   # This test is therefore slightly more accurate than "test -f" to check for file presence.
19581   # It is also a way to make sure we got the proper file name for the real test later on.
19582   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
19583   if test "x$test_shortpath" = x; then
19584     # Short path failed, file does not exist as specified.
19585     # Try adding .exe or .cmd
19586     if test -f "${new_path}.exe"; then
19587       input_to_shortpath="${new_path}.exe"
19588     elif test -f "${new_path}.cmd"; then
19589       input_to_shortpath="${new_path}.cmd"
19590     else
19591       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
19592 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
19593       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
19594 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
19595       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19596     fi
19597   else
19598     input_to_shortpath="$new_path"
19599   fi
19600 
19601   # Call helper function which possibly converts this using DOS-style short mode.
19602   # If so, the updated path is stored in $new_path.
19603   new_path="$input_to_shortpath"
19604 
19605   input_path="$input_to_shortpath"
19606   # Check if we need to convert this using DOS-style short mode. If the path
19607   # contains just simple characters, use it. Otherwise (spaces, weird characters),
19608   # take no chances and rewrite it.
19609   # Note: m4 eats our [], so we need to use [ and ] instead.
19610   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
19611   if test "x$has_forbidden_chars" != x; then
19612     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
19613     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
19614     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
19615     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
19616       # Going to short mode and back again did indeed matter. Since short mode is
19617       # case insensitive, let's make it lowercase to improve readability.
19618       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
19619       # Now convert it back to Unix-style (cygpath)
19620       input_path=`$CYGPATH -u "$shortmode_path"`
19621       new_path="$input_path"
19622     fi
19623   fi
19624 
19625   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
19626   if test "x$test_cygdrive_prefix" = x; then
19627     # As a simple fix, exclude /usr/bin since it's not a real path.
19628     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
19629       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
19630       # a path prefixed by /cygdrive for fixpath to work.
19631       new_path="$CYGWIN_ROOT_PATH$input_path"
19632     fi
19633   fi
19634 
19635   # remove trailing .exe if any
19636   new_path="${new_path/%.exe/}"
19637 
19638     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19639 
19640   # First separate the path from the arguments. This will split at the first
19641   # space.
19642   complete="$FOUND_MAKE"
19643   path="${complete%% *}"
19644   tmp="$complete EOL"
19645   arguments="${tmp#* }"
19646 
19647   # Input might be given as Windows format, start by converting to
19648   # unix format.
19649   new_path="$path"
19650 
19651   windows_path="$new_path"
19652   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19653     unix_path=`$CYGPATH -u "$windows_path"`
19654     new_path="$unix_path"
19655   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19656     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19657     new_path="$unix_path"
19658   fi
19659 
19660 
19661   # Now try to locate executable using which
19662   new_path=`$WHICH "$new_path" 2> /dev/null`
19663 
19664   if test "x$new_path" = x; then
19665     # Oops. Which didn't find the executable.
19666     # The splitting of arguments from the executable at a space might have been incorrect,
19667     # since paths with space are more likely in Windows. Give it another try with the whole
19668     # argument.
19669     path="$complete"
19670     arguments="EOL"
19671     new_path="$path"
19672 
19673   windows_path="$new_path"
19674   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19675     unix_path=`$CYGPATH -u "$windows_path"`
19676     new_path="$unix_path"
19677   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19678     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19679     new_path="$unix_path"
19680   fi
19681 
19682 
19683     new_path=`$WHICH "$new_path" 2> /dev/null`
19684     # bat and cmd files are not always considered executable in MSYS causing which
19685     # to not find them
19686     if test "x$new_path" = x \
19687         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19688         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19689       new_path="$path"
19690 
19691   windows_path="$new_path"
19692   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19693     unix_path=`$CYGPATH -u "$windows_path"`
19694     new_path="$unix_path"
19695   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19696     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19697     new_path="$unix_path"
19698   fi
19699 
19700     fi
19701 
19702     if test "x$new_path" = x; then
19703       # It's still not found. Now this is an unrecoverable error.
19704       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19705 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19706       has_space=`$ECHO "$complete" | $GREP " "`
19707       if test "x$has_space" != x; then
19708         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
19709 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
19710       fi
19711       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19712     fi
19713   fi
19714 
19715   # Now new_path has a complete unix path to the binary
19716   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
19717     # Keep paths in /bin as-is, but remove trailing .exe if any
19718     new_path="${new_path/%.exe/}"
19719     # Do not save /bin paths to all_fixpath_prefixes!
19720   else
19721     # Not in mixed or Windows style, start by that.
19722     new_path=`cmd //c echo $new_path`
19723 
19724   input_path="$new_path"
19725   # Check if we need to convert this using DOS-style short mode. If the path
19726   # contains just simple characters, use it. Otherwise (spaces, weird characters),
19727   # take no chances and rewrite it.
19728   # Note: m4 eats our [], so we need to use [ and ] instead.
19729   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
19730   if test "x$has_forbidden_chars" != x; then
19731     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
19732     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
19733   fi
19734 
19735     # Output is in $new_path
19736 
19737   windows_path="$new_path"
19738   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19739     unix_path=`$CYGPATH -u "$windows_path"`
19740     new_path="$unix_path"
19741   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19742     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19743     new_path="$unix_path"
19744   fi
19745 
19746     # remove trailing .exe if any
19747     new_path="${new_path/%.exe/}"
19748 
19749     # Save the first 10 bytes of this path to the storage, so fixpath can work.
19750     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
19751   fi
19752 
19753     else
19754       # We're on a unix platform. Hooray! :)
19755       # First separate the path from the arguments. This will split at the first
19756       # space.
19757       complete="$FOUND_MAKE"
19758       path="${complete%% *}"
19759       tmp="$complete EOL"
19760       arguments="${tmp#* }"
19761 
19762       # Cannot rely on the command "which" here since it doesn't always work.
19763       is_absolute_path=`$ECHO "$path" | $GREP ^/`
19764       if test -z "$is_absolute_path"; then
19765         # Path to executable is not absolute. Find it.
19766         IFS_save="$IFS"
19767         IFS=:
19768         for p in $PATH; do
19769           if test -f "$p/$path" && test -x "$p/$path"; then
19770             new_path="$p/$path"
19771             break
19772           fi
19773         done
19774         IFS="$IFS_save"
19775       else
19776         # This is an absolute path, we can use it without further modifications.
19777         new_path="$path"
19778       fi
19779 
19780       if test "x$new_path" = x; then
19781         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19782 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19783         has_space=`$ECHO "$complete" | $GREP " "`
19784         if test "x$has_space" != x; then
19785           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
19786 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
19787         fi
19788         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19789       fi
19790     fi
19791 
19792     # Now join together the path and the arguments once again
19793     if test "x$arguments" != xEOL; then
19794       new_complete="$new_path ${arguments% *}"
19795     else
19796       new_complete="$new_path"
19797     fi
19798 
19799     if test "x$complete" != "x$new_complete"; then
19800       FOUND_MAKE="$new_complete"
19801       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
19802 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
19803     fi
19804   fi
19805 
19806         fi
19807       fi
19808     fi
19809   fi
19810 
19811         if test "x$FOUND_MAKE" = x; then
19812           for ac_prog in make
19813 do
19814   # Extract the first word of "$ac_prog", so it can be a program name with args.
19815 set dummy $ac_prog; ac_word=$2
19816 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19817 $as_echo_n "checking for $ac_word... " >&6; }
19818 if ${ac_cv_path_CHECK_TOOLSDIR_MAKE+:} false; then :
19819   $as_echo_n "(cached) " >&6
19820 else
19821   case $CHECK_TOOLSDIR_MAKE in
19822   [\\/]* | ?:[\\/]*)
19823   ac_cv_path_CHECK_TOOLSDIR_MAKE="$CHECK_TOOLSDIR_MAKE" # Let the user override the test with a path.
19824   ;;
19825   *)
19826   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19827 for as_dir in $PATH
19828 do
19829   IFS=$as_save_IFS
19830   test -z "$as_dir" && as_dir=.
19831     for ac_exec_ext in '' $ac_executable_extensions; do
19832   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19833     ac_cv_path_CHECK_TOOLSDIR_MAKE="$as_dir/$ac_word$ac_exec_ext"
19834     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19835     break 2
19836   fi
19837 done
19838   done
19839 IFS=$as_save_IFS
19840 
19841   ;;
19842 esac
19843 fi
19844 CHECK_TOOLSDIR_MAKE=$ac_cv_path_CHECK_TOOLSDIR_MAKE
19845 if test -n "$CHECK_TOOLSDIR_MAKE"; then
19846   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_MAKE" >&5
19847 $as_echo "$CHECK_TOOLSDIR_MAKE" >&6; }
19848 else
19849   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19850 $as_echo "no" >&6; }
19851 fi
19852 
19853 
19854   test -n "$CHECK_TOOLSDIR_MAKE" && break
19855 done
19856 
19857 
19858   MAKE_CANDIDATE=""$CHECK_TOOLSDIR_MAKE""
19859   DESCRIPTION="make in tools-dir"
19860 
19861   # On Cygwin, we require a newer version of make than on other platforms
19862   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19863     MAKE_VERSION_EXPR="-e 4\."
19864     MAKE_REQUIRED_VERSION="4.0"
19865    else
19866     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
19867     MAKE_REQUIRED_VERSION="3.81"
19868   fi
19869 
19870   if test "x$MAKE_CANDIDATE" != x; then
19871     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
19872 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
19873     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
19874     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
19875     if test "x$IS_GNU_MAKE" = x; then
19876       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
19877 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
19878     else
19879       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
19880       if test "x$IS_MODERN_MAKE" = x; then
19881         { $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
19882 $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;}
19883       else
19884         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
19885           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19886             MAKE_EXPECTED_ENV='cygwin'
19887           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19888             MAKE_EXPECTED_ENV='msys'
19889           else
19890             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
19891           fi
19892           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
19893           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
19894         else
19895           # Not relevant for non-Windows
19896           IS_MAKE_CORRECT_ENV=true
19897         fi
19898         if test "x$IS_MAKE_CORRECT_ENV" = x; then
19899           { $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
19900 $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;}
19901         else
19902           FOUND_MAKE=$MAKE_CANDIDATE
19903 
19904   # Only process if variable expands to non-empty
19905 
19906   if test "x$FOUND_MAKE" != x; then
19907     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19908 
19909   # First separate the path from the arguments. This will split at the first
19910   # space.
19911   complete="$FOUND_MAKE"
19912   path="${complete%% *}"
19913   tmp="$complete EOL"
19914   arguments="${tmp#* }"
19915 
19916   # Input might be given as Windows format, start by converting to
19917   # unix format.
19918   new_path=`$CYGPATH -u "$path"`
19919 
19920   # Now try to locate executable using which
19921   new_path=`$WHICH "$new_path" 2> /dev/null`
19922   # bat and cmd files are not always considered executable in cygwin causing which
19923   # to not find them
19924   if test "x$new_path" = x \
19925       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19926       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19927     new_path=`$CYGPATH -u "$path"`
19928   fi
19929   if test "x$new_path" = x; then
19930     # Oops. Which didn't find the executable.
19931     # The splitting of arguments from the executable at a space might have been incorrect,
19932     # since paths with space are more likely in Windows. Give it another try with the whole
19933     # argument.
19934     path="$complete"
19935     arguments="EOL"
19936     new_path=`$CYGPATH -u "$path"`
19937     new_path=`$WHICH "$new_path" 2> /dev/null`
19938     # bat and cmd files are not always considered executable in cygwin causing which
19939     # to not find them
19940     if test "x$new_path" = x \
19941         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19942         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19943       new_path=`$CYGPATH -u "$path"`
19944     fi
19945     if test "x$new_path" = x; then
19946       # It's still not found. Now this is an unrecoverable error.
19947       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19948 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19949       has_space=`$ECHO "$complete" | $GREP " "`
19950       if test "x$has_space" != x; then
19951         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
19952 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
19953       fi
19954       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19955     fi
19956   fi
19957 
19958   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
19959   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
19960   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
19961   # "foo.exe" is OK but "foo" is an error.
19962   #
19963   # This test is therefore slightly more accurate than "test -f" to check for file presence.
19964   # It is also a way to make sure we got the proper file name for the real test later on.
19965   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
19966   if test "x$test_shortpath" = x; then
19967     # Short path failed, file does not exist as specified.
19968     # Try adding .exe or .cmd
19969     if test -f "${new_path}.exe"; then
19970       input_to_shortpath="${new_path}.exe"
19971     elif test -f "${new_path}.cmd"; then
19972       input_to_shortpath="${new_path}.cmd"
19973     else
19974       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
19975 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
19976       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
19977 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
19978       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19979     fi
19980   else
19981     input_to_shortpath="$new_path"
19982   fi
19983 
19984   # Call helper function which possibly converts this using DOS-style short mode.
19985   # If so, the updated path is stored in $new_path.
19986   new_path="$input_to_shortpath"
19987 
19988   input_path="$input_to_shortpath"
19989   # Check if we need to convert this using DOS-style short mode. If the path
19990   # contains just simple characters, use it. Otherwise (spaces, weird characters),
19991   # take no chances and rewrite it.
19992   # Note: m4 eats our [], so we need to use [ and ] instead.
19993   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
19994   if test "x$has_forbidden_chars" != x; then
19995     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
19996     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
19997     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
19998     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
19999       # Going to short mode and back again did indeed matter. Since short mode is
20000       # case insensitive, let's make it lowercase to improve readability.
20001       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20002       # Now convert it back to Unix-style (cygpath)
20003       input_path=`$CYGPATH -u "$shortmode_path"`
20004       new_path="$input_path"
20005     fi
20006   fi
20007 
20008   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20009   if test "x$test_cygdrive_prefix" = x; then
20010     # As a simple fix, exclude /usr/bin since it's not a real path.
20011     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
20012       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20013       # a path prefixed by /cygdrive for fixpath to work.
20014       new_path="$CYGWIN_ROOT_PATH$input_path"
20015     fi
20016   fi
20017 
20018   # remove trailing .exe if any
20019   new_path="${new_path/%.exe/}"
20020 
20021     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20022 
20023   # First separate the path from the arguments. This will split at the first
20024   # space.
20025   complete="$FOUND_MAKE"
20026   path="${complete%% *}"
20027   tmp="$complete EOL"
20028   arguments="${tmp#* }"
20029 
20030   # Input might be given as Windows format, start by converting to
20031   # unix format.
20032   new_path="$path"
20033 
20034   windows_path="$new_path"
20035   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20036     unix_path=`$CYGPATH -u "$windows_path"`
20037     new_path="$unix_path"
20038   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20039     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20040     new_path="$unix_path"
20041   fi
20042 
20043 
20044   # Now try to locate executable using which
20045   new_path=`$WHICH "$new_path" 2> /dev/null`
20046 
20047   if test "x$new_path" = x; then
20048     # Oops. Which didn't find the executable.
20049     # The splitting of arguments from the executable at a space might have been incorrect,
20050     # since paths with space are more likely in Windows. Give it another try with the whole
20051     # argument.
20052     path="$complete"
20053     arguments="EOL"
20054     new_path="$path"
20055 
20056   windows_path="$new_path"
20057   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20058     unix_path=`$CYGPATH -u "$windows_path"`
20059     new_path="$unix_path"
20060   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20061     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20062     new_path="$unix_path"
20063   fi
20064 
20065 
20066     new_path=`$WHICH "$new_path" 2> /dev/null`
20067     # bat and cmd files are not always considered executable in MSYS causing which
20068     # to not find them
20069     if test "x$new_path" = x \
20070         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
20071         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
20072       new_path="$path"
20073 
20074   windows_path="$new_path"
20075   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20076     unix_path=`$CYGPATH -u "$windows_path"`
20077     new_path="$unix_path"
20078   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20079     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20080     new_path="$unix_path"
20081   fi
20082 
20083     fi
20084 
20085     if test "x$new_path" = x; then
20086       # It's still not found. Now this is an unrecoverable error.
20087       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
20088 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
20089       has_space=`$ECHO "$complete" | $GREP " "`
20090       if test "x$has_space" != x; then
20091         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
20092 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
20093       fi
20094       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
20095     fi
20096   fi
20097 
20098   # Now new_path has a complete unix path to the binary
20099   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
20100     # Keep paths in /bin as-is, but remove trailing .exe if any
20101     new_path="${new_path/%.exe/}"
20102     # Do not save /bin paths to all_fixpath_prefixes!
20103   else
20104     # Not in mixed or Windows style, start by that.
20105     new_path=`cmd //c echo $new_path`
20106 
20107   input_path="$new_path"
20108   # Check if we need to convert this using DOS-style short mode. If the path
20109   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20110   # take no chances and rewrite it.
20111   # Note: m4 eats our [], so we need to use [ and ] instead.
20112   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20113   if test "x$has_forbidden_chars" != x; then
20114     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20115     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20116   fi
20117 
20118     # Output is in $new_path
20119 
20120   windows_path="$new_path"
20121   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20122     unix_path=`$CYGPATH -u "$windows_path"`
20123     new_path="$unix_path"
20124   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20125     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20126     new_path="$unix_path"
20127   fi
20128 
20129     # remove trailing .exe if any
20130     new_path="${new_path/%.exe/}"
20131 
20132     # Save the first 10 bytes of this path to the storage, so fixpath can work.
20133     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20134   fi
20135 
20136     else
20137       # We're on a unix platform. Hooray! :)
20138       # First separate the path from the arguments. This will split at the first
20139       # space.
20140       complete="$FOUND_MAKE"
20141       path="${complete%% *}"
20142       tmp="$complete EOL"
20143       arguments="${tmp#* }"
20144 
20145       # Cannot rely on the command "which" here since it doesn't always work.
20146       is_absolute_path=`$ECHO "$path" | $GREP ^/`
20147       if test -z "$is_absolute_path"; then
20148         # Path to executable is not absolute. Find it.
20149         IFS_save="$IFS"
20150         IFS=:
20151         for p in $PATH; do
20152           if test -f "$p/$path" && test -x "$p/$path"; then
20153             new_path="$p/$path"
20154             break
20155           fi
20156         done
20157         IFS="$IFS_save"
20158       else
20159         # This is an absolute path, we can use it without further modifications.
20160         new_path="$path"
20161       fi
20162 
20163       if test "x$new_path" = x; then
20164         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
20165 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
20166         has_space=`$ECHO "$complete" | $GREP " "`
20167         if test "x$has_space" != x; then
20168           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
20169 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
20170         fi
20171         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
20172       fi
20173     fi
20174 
20175     # Now join together the path and the arguments once again
20176     if test "x$arguments" != xEOL; then
20177       new_complete="$new_path ${arguments% *}"
20178     else
20179       new_complete="$new_path"
20180     fi
20181 
20182     if test "x$complete" != "x$new_complete"; then
20183       FOUND_MAKE="$new_complete"
20184       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
20185 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
20186     fi
20187   fi
20188 
20189         fi
20190       fi
20191     fi
20192   fi
20193 
20194         fi
20195         PATH=$OLD_PATH
20196       fi
20197     fi
20198 
20199     if test "x$FOUND_MAKE" = x; then
20200       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
20201     fi
20202 
20203     else
20204       # If it succeeded, then it was overridden by the user. We will use it
20205       # for the tool.
20206 
20207       # First remove it from the list of overridden variables, so we can test
20208       # for unknown variables in the end.
20209       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
20210 
20211       # Check if we try to supply an empty value
20212       if test "x$MAKE" = x; then
20213         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool MAKE= (no value)" >&5
20214 $as_echo "$as_me: Setting user supplied tool MAKE= (no value)" >&6;}
20215         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MAKE" >&5
20216 $as_echo_n "checking for MAKE... " >&6; }
20217         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
20218 $as_echo "disabled" >&6; }
20219       else
20220         # Check if the provided tool contains a complete path.
20221         tool_specified="$MAKE"
20222         tool_basename="${tool_specified##*/}"
20223         if test "x$tool_basename" = "x$tool_specified"; then
20224           # A command without a complete path is provided, search $PATH.
20225           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MAKE=$tool_basename" >&5
20226 $as_echo "$as_me: Will search for user supplied tool MAKE=$tool_basename" >&6;}
20227           # Extract the first word of "$tool_basename", so it can be a program name with args.
20228 set dummy $tool_basename; ac_word=$2
20229 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
20230 $as_echo_n "checking for $ac_word... " >&6; }
20231 if ${ac_cv_path_MAKE+:} false; then :
20232   $as_echo_n "(cached) " >&6
20233 else
20234   case $MAKE in
20235   [\\/]* | ?:[\\/]*)
20236   ac_cv_path_MAKE="$MAKE" # Let the user override the test with a path.
20237   ;;
20238   *)
20239   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
20240 for as_dir in $PATH
20241 do
20242   IFS=$as_save_IFS
20243   test -z "$as_dir" && as_dir=.
20244     for ac_exec_ext in '' $ac_executable_extensions; do
20245   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
20246     ac_cv_path_MAKE="$as_dir/$ac_word$ac_exec_ext"
20247     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
20248     break 2
20249   fi
20250 done
20251   done
20252 IFS=$as_save_IFS
20253 
20254   ;;
20255 esac
20256 fi
20257 MAKE=$ac_cv_path_MAKE
20258 if test -n "$MAKE"; then
20259   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MAKE" >&5
20260 $as_echo "$MAKE" >&6; }
20261 else
20262   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20263 $as_echo "no" >&6; }
20264 fi
20265 
20266 
20267           if test "x$MAKE" = x; then
20268             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
20269           fi
20270         else
20271           # Otherwise we believe it is a complete path. Use it as it is.
20272           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MAKE=$tool_specified" >&5
20273 $as_echo "$as_me: Will use user supplied tool MAKE=$tool_specified" >&6;}
20274           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MAKE" >&5
20275 $as_echo_n "checking for MAKE... " >&6; }
20276           if test ! -x "$tool_specified"; then
20277             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
20278 $as_echo "not found" >&6; }
20279             as_fn_error $? "User supplied tool MAKE=$tool_specified does not exist or is not executable" "$LINENO" 5
20280           fi
20281           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
20282 $as_echo "$tool_specified" >&6; }
20283         fi
20284       fi
20285     fi
20286 
20287     # If MAKE was set by user, verify the version
20288 
20289   MAKE_CANDIDATE=""$MAKE""
20290   DESCRIPTION="user supplied MAKE=$MAKE"
20291 
20292   # On Cygwin, we require a newer version of make than on other platforms
20293   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20294     MAKE_VERSION_EXPR="-e 4\."
20295     MAKE_REQUIRED_VERSION="4.0"
20296    else
20297     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
20298     MAKE_REQUIRED_VERSION="3.81"
20299   fi
20300 
20301   if test "x$MAKE_CANDIDATE" != x; then
20302     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
20303 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
20304     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
20305     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
20306     if test "x$IS_GNU_MAKE" = x; then
20307       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
20308 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
20309     else
20310       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
20311       if test "x$IS_MODERN_MAKE" = x; then
20312         { $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
20313 $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;}
20314       else
20315         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
20316           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20317             MAKE_EXPECTED_ENV='cygwin'
20318           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20319             MAKE_EXPECTED_ENV='msys'
20320           else
20321             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
20322           fi
20323           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
20324           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
20325         else
20326           # Not relevant for non-Windows
20327           IS_MAKE_CORRECT_ENV=true
20328         fi
20329         if test "x$IS_MAKE_CORRECT_ENV" = x; then
20330           { $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
20331 $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;}
20332         else
20333           FOUND_MAKE=$MAKE_CANDIDATE
20334 
20335   # Only process if variable expands to non-empty
20336 
20337   if test "x$FOUND_MAKE" != x; then
20338     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20339 
20340   # First separate the path from the arguments. This will split at the first
20341   # space.
20342   complete="$FOUND_MAKE"
20343   path="${complete%% *}"
20344   tmp="$complete EOL"
20345   arguments="${tmp#* }"
20346 
20347   # Input might be given as Windows format, start by converting to
20348   # unix format.
20349   new_path=`$CYGPATH -u "$path"`
20350 
20351   # Now try to locate executable using which
20352   new_path=`$WHICH "$new_path" 2> /dev/null`
20353   # bat and cmd files are not always considered executable in cygwin causing which
20354   # to not find them
20355   if test "x$new_path" = x \
20356       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
20357       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
20358     new_path=`$CYGPATH -u "$path"`
20359   fi
20360   if test "x$new_path" = x; then
20361     # Oops. Which didn't find the executable.
20362     # The splitting of arguments from the executable at a space might have been incorrect,
20363     # since paths with space are more likely in Windows. Give it another try with the whole
20364     # argument.
20365     path="$complete"
20366     arguments="EOL"
20367     new_path=`$CYGPATH -u "$path"`
20368     new_path=`$WHICH "$new_path" 2> /dev/null`
20369     # bat and cmd files are not always considered executable in cygwin causing which
20370     # to not find them
20371     if test "x$new_path" = x \
20372         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
20373         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
20374       new_path=`$CYGPATH -u "$path"`
20375     fi
20376     if test "x$new_path" = x; then
20377       # It's still not found. Now this is an unrecoverable error.
20378       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
20379 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
20380       has_space=`$ECHO "$complete" | $GREP " "`
20381       if test "x$has_space" != x; then
20382         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
20383 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
20384       fi
20385       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
20386     fi
20387   fi
20388 
20389   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
20390   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
20391   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
20392   # "foo.exe" is OK but "foo" is an error.
20393   #
20394   # This test is therefore slightly more accurate than "test -f" to check for file presence.
20395   # It is also a way to make sure we got the proper file name for the real test later on.
20396   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
20397   if test "x$test_shortpath" = x; then
20398     # Short path failed, file does not exist as specified.
20399     # Try adding .exe or .cmd
20400     if test -f "${new_path}.exe"; then
20401       input_to_shortpath="${new_path}.exe"
20402     elif test -f "${new_path}.cmd"; then
20403       input_to_shortpath="${new_path}.cmd"
20404     else
20405       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
20406 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
20407       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
20408 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
20409       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
20410     fi
20411   else
20412     input_to_shortpath="$new_path"
20413   fi
20414 
20415   # Call helper function which possibly converts this using DOS-style short mode.
20416   # If so, the updated path is stored in $new_path.
20417   new_path="$input_to_shortpath"
20418 
20419   input_path="$input_to_shortpath"
20420   # Check if we need to convert this using DOS-style short mode. If the path
20421   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20422   # take no chances and rewrite it.
20423   # Note: m4 eats our [], so we need to use [ and ] instead.
20424   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20425   if test "x$has_forbidden_chars" != x; then
20426     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20427     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20428     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20429     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20430       # Going to short mode and back again did indeed matter. Since short mode is
20431       # case insensitive, let's make it lowercase to improve readability.
20432       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20433       # Now convert it back to Unix-style (cygpath)
20434       input_path=`$CYGPATH -u "$shortmode_path"`
20435       new_path="$input_path"
20436     fi
20437   fi
20438 
20439   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20440   if test "x$test_cygdrive_prefix" = x; then
20441     # As a simple fix, exclude /usr/bin since it's not a real path.
20442     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
20443       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20444       # a path prefixed by /cygdrive for fixpath to work.
20445       new_path="$CYGWIN_ROOT_PATH$input_path"
20446     fi
20447   fi
20448 
20449   # remove trailing .exe if any
20450   new_path="${new_path/%.exe/}"
20451 
20452     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20453 
20454   # First separate the path from the arguments. This will split at the first
20455   # space.
20456   complete="$FOUND_MAKE"
20457   path="${complete%% *}"
20458   tmp="$complete EOL"
20459   arguments="${tmp#* }"
20460 
20461   # Input might be given as Windows format, start by converting to
20462   # unix format.
20463   new_path="$path"
20464 
20465   windows_path="$new_path"
20466   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20467     unix_path=`$CYGPATH -u "$windows_path"`
20468     new_path="$unix_path"
20469   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20470     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20471     new_path="$unix_path"
20472   fi
20473 
20474 
20475   # Now try to locate executable using which
20476   new_path=`$WHICH "$new_path" 2> /dev/null`
20477 
20478   if test "x$new_path" = x; then
20479     # Oops. Which didn't find the executable.
20480     # The splitting of arguments from the executable at a space might have been incorrect,
20481     # since paths with space are more likely in Windows. Give it another try with the whole
20482     # argument.
20483     path="$complete"
20484     arguments="EOL"
20485     new_path="$path"
20486 
20487   windows_path="$new_path"
20488   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20489     unix_path=`$CYGPATH -u "$windows_path"`
20490     new_path="$unix_path"
20491   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20492     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20493     new_path="$unix_path"
20494   fi
20495 
20496 
20497     new_path=`$WHICH "$new_path" 2> /dev/null`
20498     # bat and cmd files are not always considered executable in MSYS causing which
20499     # to not find them
20500     if test "x$new_path" = x \
20501         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
20502         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
20503       new_path="$path"
20504 
20505   windows_path="$new_path"
20506   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20507     unix_path=`$CYGPATH -u "$windows_path"`
20508     new_path="$unix_path"
20509   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20510     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20511     new_path="$unix_path"
20512   fi
20513 
20514     fi
20515 
20516     if test "x$new_path" = x; then
20517       # It's still not found. Now this is an unrecoverable error.
20518       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
20519 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
20520       has_space=`$ECHO "$complete" | $GREP " "`
20521       if test "x$has_space" != x; then
20522         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
20523 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
20524       fi
20525       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
20526     fi
20527   fi
20528 
20529   # Now new_path has a complete unix path to the binary
20530   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
20531     # Keep paths in /bin as-is, but remove trailing .exe if any
20532     new_path="${new_path/%.exe/}"
20533     # Do not save /bin paths to all_fixpath_prefixes!
20534   else
20535     # Not in mixed or Windows style, start by that.
20536     new_path=`cmd //c echo $new_path`
20537 
20538   input_path="$new_path"
20539   # Check if we need to convert this using DOS-style short mode. If the path
20540   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20541   # take no chances and rewrite it.
20542   # Note: m4 eats our [], so we need to use [ and ] instead.
20543   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20544   if test "x$has_forbidden_chars" != x; then
20545     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20546     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20547   fi
20548 
20549     # Output is in $new_path
20550 
20551   windows_path="$new_path"
20552   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20553     unix_path=`$CYGPATH -u "$windows_path"`
20554     new_path="$unix_path"
20555   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20556     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20557     new_path="$unix_path"
20558   fi
20559 
20560     # remove trailing .exe if any
20561     new_path="${new_path/%.exe/}"
20562 
20563     # Save the first 10 bytes of this path to the storage, so fixpath can work.
20564     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20565   fi
20566 
20567     else
20568       # We're on a unix platform. Hooray! :)
20569       # First separate the path from the arguments. This will split at the first
20570       # space.
20571       complete="$FOUND_MAKE"
20572       path="${complete%% *}"
20573       tmp="$complete EOL"
20574       arguments="${tmp#* }"
20575 
20576       # Cannot rely on the command "which" here since it doesn't always work.
20577       is_absolute_path=`$ECHO "$path" | $GREP ^/`
20578       if test -z "$is_absolute_path"; then
20579         # Path to executable is not absolute. Find it.
20580         IFS_save="$IFS"
20581         IFS=:
20582         for p in $PATH; do
20583           if test -f "$p/$path" && test -x "$p/$path"; then
20584             new_path="$p/$path"
20585             break
20586           fi
20587         done
20588         IFS="$IFS_save"
20589       else
20590         # This is an absolute path, we can use it without further modifications.
20591         new_path="$path"
20592       fi
20593 
20594       if test "x$new_path" = x; then
20595         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
20596 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
20597         has_space=`$ECHO "$complete" | $GREP " "`
20598         if test "x$has_space" != x; then
20599           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
20600 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
20601         fi
20602         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
20603       fi
20604     fi
20605 
20606     # Now join together the path and the arguments once again
20607     if test "x$arguments" != xEOL; then
20608       new_complete="$new_path ${arguments% *}"
20609     else
20610       new_complete="$new_path"
20611     fi
20612 
20613     if test "x$complete" != "x$new_complete"; then
20614       FOUND_MAKE="$new_complete"
20615       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
20616 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
20617     fi
20618   fi
20619 
20620         fi
20621       fi
20622     fi
20623   fi
20624 
20625     if test "x$FOUND_MAKE" = x; then
20626       as_fn_error $? "The specified make (by MAKE=$MAKE) is not GNU make $MAKE_REQUIRED_VERSION or newer." "$LINENO" 5
20627     fi
20628 
20629   fi
20630 
20631 
20632   MAKE=$FOUND_MAKE
20633 
20634   { $as_echo "$as_me:${as_lineno-$LINENO}: Using GNU make at $FOUND_MAKE (version: $MAKE_VERSION_STRING)" >&5
20635 $as_echo "$as_me: Using GNU make at $FOUND_MAKE (version: $MAKE_VERSION_STRING)" >&6;}
20636 
20637 
20638   # Check if make supports the output sync option and if so, setup using it.
20639   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if make --output-sync is supported" >&5
20640 $as_echo_n "checking if make --output-sync is supported... " >&6; }
20641   if $MAKE --version -O > /dev/null 2>&1; then
20642     OUTPUT_SYNC_SUPPORTED=true
20643     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
20644 $as_echo "yes" >&6; }
20645     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for output-sync value" >&5
20646 $as_echo_n "checking for output-sync value... " >&6; }
20647 
20648 # Check whether --with-output-sync was given.
20649 if test "${with_output_sync+set}" = set; then :
20650   withval=$with_output_sync; OUTPUT_SYNC=$with_output_sync
20651 fi
20652 
20653     if test "x$OUTPUT_SYNC" = "x"; then
20654       OUTPUT_SYNC=none
20655     fi
20656     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OUTPUT_SYNC" >&5
20657 $as_echo "$OUTPUT_SYNC" >&6; }
20658     if ! $MAKE --version -O$OUTPUT_SYNC > /dev/null 2>&1; then
20659       as_fn_error $? "Make did not the support the value $OUTPUT_SYNC as output sync type." "$LINENO" 5
20660     fi
20661   else
20662     OUTPUT_SYNC_SUPPORTED=false
20663     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20664 $as_echo "no" >&6; }
20665   fi
20666 
20667 
20668 
20669 
20670 
20671 
20672   # Test if find supports -delete
20673   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if find supports -delete" >&5
20674 $as_echo_n "checking if find supports -delete... " >&6; }
20675   FIND_DELETE="-delete"
20676 
20677   DELETEDIR=`$MKTEMP -d tmp.XXXXXXXXXX` || (echo Could not create temporary directory!; exit $?)
20678 
20679   echo Hejsan > $DELETEDIR/TestIfFindSupportsDelete
20680 
20681   TEST_DELETE=`$FIND "$DELETEDIR" -name TestIfFindSupportsDelete $FIND_DELETE 2>&1`
20682   if test -f $DELETEDIR/TestIfFindSupportsDelete; then
20683     # No, it does not.
20684     rm $DELETEDIR/TestIfFindSupportsDelete
20685     if test "x$OPENJDK_TARGET_OS" = "xaix"; then
20686       # AIX 'find' is buggy if called with '-exec {} \+' and an empty file list
20687       FIND_DELETE="-print | xargs rm"
20688     else
20689       FIND_DELETE="-exec rm \{\} \+"
20690     fi
20691     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20692 $as_echo "no" >&6; }
20693   else
20694     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
20695 $as_echo "yes" >&6; }
20696   fi
20697   rmdir $DELETEDIR
20698 
20699 
20700 
20701   # These tools might not be installed by default,
20702   # need hint on how to install them.
20703 
20704 
20705 
20706   # Publish this variable in the help.
20707 
20708 
20709   if [ -z "${UNZIP+x}" ]; then
20710     # The variable is not set by user, try to locate tool using the code snippet
20711     for ac_prog in unzip
20712 do
20713   # Extract the first word of "$ac_prog", so it can be a program name with args.
20714 set dummy $ac_prog; ac_word=$2
20715 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
20716 $as_echo_n "checking for $ac_word... " >&6; }
20717 if ${ac_cv_path_UNZIP+:} false; then :
20718   $as_echo_n "(cached) " >&6
20719 else
20720   case $UNZIP in
20721   [\\/]* | ?:[\\/]*)
20722   ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
20723   ;;
20724   *)
20725   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
20726 for as_dir in $PATH
20727 do
20728   IFS=$as_save_IFS
20729   test -z "$as_dir" && as_dir=.
20730     for ac_exec_ext in '' $ac_executable_extensions; do
20731   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
20732     ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
20733     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
20734     break 2
20735   fi
20736 done
20737   done
20738 IFS=$as_save_IFS
20739 
20740   ;;
20741 esac
20742 fi
20743 UNZIP=$ac_cv_path_UNZIP
20744 if test -n "$UNZIP"; then
20745   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
20746 $as_echo "$UNZIP" >&6; }
20747 else
20748   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20749 $as_echo "no" >&6; }
20750 fi
20751 
20752 
20753   test -n "$UNZIP" && break
20754 done
20755 
20756   else
20757     # The variable is set, but is it from the command line or the environment?
20758 
20759     # Try to remove the string !UNZIP! from our list.
20760     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNZIP!/}
20761     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
20762       # If it failed, the variable was not from the command line. Ignore it,
20763       # but warn the user (except for BASH, which is always set by the calling BASH).
20764       if test "xUNZIP" != xBASH; then
20765         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNZIP from the environment. Use command line variables instead." >&5
20766 $as_echo "$as_me: WARNING: Ignoring value of UNZIP from the environment. Use command line variables instead." >&2;}
20767       fi
20768       # Try to locate tool using the code snippet
20769       for ac_prog in unzip
20770 do
20771   # Extract the first word of "$ac_prog", so it can be a program name with args.
20772 set dummy $ac_prog; ac_word=$2
20773 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
20774 $as_echo_n "checking for $ac_word... " >&6; }
20775 if ${ac_cv_path_UNZIP+:} false; then :
20776   $as_echo_n "(cached) " >&6
20777 else
20778   case $UNZIP in
20779   [\\/]* | ?:[\\/]*)
20780   ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
20781   ;;
20782   *)
20783   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
20784 for as_dir in $PATH
20785 do
20786   IFS=$as_save_IFS
20787   test -z "$as_dir" && as_dir=.
20788     for ac_exec_ext in '' $ac_executable_extensions; do
20789   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
20790     ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
20791     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
20792     break 2
20793   fi
20794 done
20795   done
20796 IFS=$as_save_IFS
20797 
20798   ;;
20799 esac
20800 fi
20801 UNZIP=$ac_cv_path_UNZIP
20802 if test -n "$UNZIP"; then
20803   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
20804 $as_echo "$UNZIP" >&6; }
20805 else
20806   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20807 $as_echo "no" >&6; }
20808 fi
20809 
20810 
20811   test -n "$UNZIP" && break
20812 done
20813 
20814     else
20815       # If it succeeded, then it was overridden by the user. We will use it
20816       # for the tool.
20817 
20818       # First remove it from the list of overridden variables, so we can test
20819       # for unknown variables in the end.
20820       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
20821 
20822       # Check if we try to supply an empty value
20823       if test "x$UNZIP" = x; then
20824         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool UNZIP= (no value)" >&5
20825 $as_echo "$as_me: Setting user supplied tool UNZIP= (no value)" >&6;}
20826         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNZIP" >&5
20827 $as_echo_n "checking for UNZIP... " >&6; }
20828         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
20829 $as_echo "disabled" >&6; }
20830       else
20831         # Check if the provided tool contains a complete path.
20832         tool_specified="$UNZIP"
20833         tool_basename="${tool_specified##*/}"
20834         if test "x$tool_basename" = "x$tool_specified"; then
20835           # A command without a complete path is provided, search $PATH.
20836           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNZIP=$tool_basename" >&5
20837 $as_echo "$as_me: Will search for user supplied tool UNZIP=$tool_basename" >&6;}
20838           # Extract the first word of "$tool_basename", so it can be a program name with args.
20839 set dummy $tool_basename; ac_word=$2
20840 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
20841 $as_echo_n "checking for $ac_word... " >&6; }
20842 if ${ac_cv_path_UNZIP+:} false; then :
20843   $as_echo_n "(cached) " >&6
20844 else
20845   case $UNZIP in
20846   [\\/]* | ?:[\\/]*)
20847   ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
20848   ;;
20849   *)
20850   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
20851 for as_dir in $PATH
20852 do
20853   IFS=$as_save_IFS
20854   test -z "$as_dir" && as_dir=.
20855     for ac_exec_ext in '' $ac_executable_extensions; do
20856   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
20857     ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
20858     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
20859     break 2
20860   fi
20861 done
20862   done
20863 IFS=$as_save_IFS
20864 
20865   ;;
20866 esac
20867 fi
20868 UNZIP=$ac_cv_path_UNZIP
20869 if test -n "$UNZIP"; then
20870   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
20871 $as_echo "$UNZIP" >&6; }
20872 else
20873   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20874 $as_echo "no" >&6; }
20875 fi
20876 
20877 
20878           if test "x$UNZIP" = x; then
20879             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
20880           fi
20881         else
20882           # Otherwise we believe it is a complete path. Use it as it is.
20883           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNZIP=$tool_specified" >&5
20884 $as_echo "$as_me: Will use user supplied tool UNZIP=$tool_specified" >&6;}
20885           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNZIP" >&5
20886 $as_echo_n "checking for UNZIP... " >&6; }
20887           if test ! -x "$tool_specified"; then
20888             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
20889 $as_echo "not found" >&6; }
20890             as_fn_error $? "User supplied tool UNZIP=$tool_specified does not exist or is not executable" "$LINENO" 5
20891           fi
20892           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
20893 $as_echo "$tool_specified" >&6; }
20894         fi
20895       fi
20896     fi
20897 
20898   fi
20899 
20900 
20901 
20902   if test "x$UNZIP" = x; then
20903     as_fn_error $? "Could not find required tool for UNZIP" "$LINENO" 5
20904   fi
20905 
20906 
20907 
20908 
20909 
20910   # Publish this variable in the help.
20911 
20912 
20913   if [ -z "${ZIP+x}" ]; then
20914     # The variable is not set by user, try to locate tool using the code snippet
20915     for ac_prog in zip
20916 do
20917   # Extract the first word of "$ac_prog", so it can be a program name with args.
20918 set dummy $ac_prog; ac_word=$2
20919 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
20920 $as_echo_n "checking for $ac_word... " >&6; }
20921 if ${ac_cv_path_ZIP+:} false; then :
20922   $as_echo_n "(cached) " >&6
20923 else
20924   case $ZIP in
20925   [\\/]* | ?:[\\/]*)
20926   ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
20927   ;;
20928   *)
20929   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
20930 for as_dir in $PATH
20931 do
20932   IFS=$as_save_IFS
20933   test -z "$as_dir" && as_dir=.
20934     for ac_exec_ext in '' $ac_executable_extensions; do
20935   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
20936     ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
20937     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
20938     break 2
20939   fi
20940 done
20941   done
20942 IFS=$as_save_IFS
20943 
20944   ;;
20945 esac
20946 fi
20947 ZIP=$ac_cv_path_ZIP
20948 if test -n "$ZIP"; then
20949   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
20950 $as_echo "$ZIP" >&6; }
20951 else
20952   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20953 $as_echo "no" >&6; }
20954 fi
20955 
20956 
20957   test -n "$ZIP" && break
20958 done
20959 
20960   else
20961     # The variable is set, but is it from the command line or the environment?
20962 
20963     # Try to remove the string !ZIP! from our list.
20964     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!ZIP!/}
20965     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
20966       # If it failed, the variable was not from the command line. Ignore it,
20967       # but warn the user (except for BASH, which is always set by the calling BASH).
20968       if test "xZIP" != xBASH; then
20969         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ZIP from the environment. Use command line variables instead." >&5
20970 $as_echo "$as_me: WARNING: Ignoring value of ZIP from the environment. Use command line variables instead." >&2;}
20971       fi
20972       # Try to locate tool using the code snippet
20973       for ac_prog in zip
20974 do
20975   # Extract the first word of "$ac_prog", so it can be a program name with args.
20976 set dummy $ac_prog; ac_word=$2
20977 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
20978 $as_echo_n "checking for $ac_word... " >&6; }
20979 if ${ac_cv_path_ZIP+:} false; then :
20980   $as_echo_n "(cached) " >&6
20981 else
20982   case $ZIP in
20983   [\\/]* | ?:[\\/]*)
20984   ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
20985   ;;
20986   *)
20987   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
20988 for as_dir in $PATH
20989 do
20990   IFS=$as_save_IFS
20991   test -z "$as_dir" && as_dir=.
20992     for ac_exec_ext in '' $ac_executable_extensions; do
20993   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
20994     ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
20995     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
20996     break 2
20997   fi
20998 done
20999   done
21000 IFS=$as_save_IFS
21001 
21002   ;;
21003 esac
21004 fi
21005 ZIP=$ac_cv_path_ZIP
21006 if test -n "$ZIP"; then
21007   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
21008 $as_echo "$ZIP" >&6; }
21009 else
21010   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21011 $as_echo "no" >&6; }
21012 fi
21013 
21014 
21015   test -n "$ZIP" && break
21016 done
21017 
21018     else
21019       # If it succeeded, then it was overridden by the user. We will use it
21020       # for the tool.
21021 
21022       # First remove it from the list of overridden variables, so we can test
21023       # for unknown variables in the end.
21024       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
21025 
21026       # Check if we try to supply an empty value
21027       if test "x$ZIP" = x; then
21028         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool ZIP= (no value)" >&5
21029 $as_echo "$as_me: Setting user supplied tool ZIP= (no value)" >&6;}
21030         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ZIP" >&5
21031 $as_echo_n "checking for ZIP... " >&6; }
21032         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
21033 $as_echo "disabled" >&6; }
21034       else
21035         # Check if the provided tool contains a complete path.
21036         tool_specified="$ZIP"
21037         tool_basename="${tool_specified##*/}"
21038         if test "x$tool_basename" = "x$tool_specified"; then
21039           # A command without a complete path is provided, search $PATH.
21040           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ZIP=$tool_basename" >&5
21041 $as_echo "$as_me: Will search for user supplied tool ZIP=$tool_basename" >&6;}
21042           # Extract the first word of "$tool_basename", so it can be a program name with args.
21043 set dummy $tool_basename; ac_word=$2
21044 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21045 $as_echo_n "checking for $ac_word... " >&6; }
21046 if ${ac_cv_path_ZIP+:} false; then :
21047   $as_echo_n "(cached) " >&6
21048 else
21049   case $ZIP in
21050   [\\/]* | ?:[\\/]*)
21051   ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
21052   ;;
21053   *)
21054   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21055 for as_dir in $PATH
21056 do
21057   IFS=$as_save_IFS
21058   test -z "$as_dir" && as_dir=.
21059     for ac_exec_ext in '' $ac_executable_extensions; do
21060   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21061     ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
21062     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21063     break 2
21064   fi
21065 done
21066   done
21067 IFS=$as_save_IFS
21068 
21069   ;;
21070 esac
21071 fi
21072 ZIP=$ac_cv_path_ZIP
21073 if test -n "$ZIP"; then
21074   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
21075 $as_echo "$ZIP" >&6; }
21076 else
21077   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21078 $as_echo "no" >&6; }
21079 fi
21080 
21081 
21082           if test "x$ZIP" = x; then
21083             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
21084           fi
21085         else
21086           # Otherwise we believe it is a complete path. Use it as it is.
21087           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ZIP=$tool_specified" >&5
21088 $as_echo "$as_me: Will use user supplied tool ZIP=$tool_specified" >&6;}
21089           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ZIP" >&5
21090 $as_echo_n "checking for ZIP... " >&6; }
21091           if test ! -x "$tool_specified"; then
21092             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
21093 $as_echo "not found" >&6; }
21094             as_fn_error $? "User supplied tool ZIP=$tool_specified does not exist or is not executable" "$LINENO" 5
21095           fi
21096           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
21097 $as_echo "$tool_specified" >&6; }
21098         fi
21099       fi
21100     fi
21101 
21102   fi
21103 
21104 
21105 
21106   if test "x$ZIP" = x; then
21107     as_fn_error $? "Could not find required tool for ZIP" "$LINENO" 5
21108   fi
21109 
21110 
21111 
21112   # Non-required basic tools
21113 
21114 
21115 
21116   # Publish this variable in the help.
21117 
21118 
21119   if [ -z "${LDD+x}" ]; then
21120     # The variable is not set by user, try to locate tool using the code snippet
21121     for ac_prog in ldd
21122 do
21123   # Extract the first word of "$ac_prog", so it can be a program name with args.
21124 set dummy $ac_prog; ac_word=$2
21125 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21126 $as_echo_n "checking for $ac_word... " >&6; }
21127 if ${ac_cv_path_LDD+:} false; then :
21128   $as_echo_n "(cached) " >&6
21129 else
21130   case $LDD in
21131   [\\/]* | ?:[\\/]*)
21132   ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
21133   ;;
21134   *)
21135   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21136 for as_dir in $PATH
21137 do
21138   IFS=$as_save_IFS
21139   test -z "$as_dir" && as_dir=.
21140     for ac_exec_ext in '' $ac_executable_extensions; do
21141   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21142     ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
21143     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21144     break 2
21145   fi
21146 done
21147   done
21148 IFS=$as_save_IFS
21149 
21150   ;;
21151 esac
21152 fi
21153 LDD=$ac_cv_path_LDD
21154 if test -n "$LDD"; then
21155   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
21156 $as_echo "$LDD" >&6; }
21157 else
21158   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21159 $as_echo "no" >&6; }
21160 fi
21161 
21162 
21163   test -n "$LDD" && break
21164 done
21165 
21166   else
21167     # The variable is set, but is it from the command line or the environment?
21168 
21169     # Try to remove the string !LDD! from our list.
21170     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LDD!/}
21171     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
21172       # If it failed, the variable was not from the command line. Ignore it,
21173       # but warn the user (except for BASH, which is always set by the calling BASH).
21174       if test "xLDD" != xBASH; then
21175         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LDD from the environment. Use command line variables instead." >&5
21176 $as_echo "$as_me: WARNING: Ignoring value of LDD from the environment. Use command line variables instead." >&2;}
21177       fi
21178       # Try to locate tool using the code snippet
21179       for ac_prog in ldd
21180 do
21181   # Extract the first word of "$ac_prog", so it can be a program name with args.
21182 set dummy $ac_prog; ac_word=$2
21183 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21184 $as_echo_n "checking for $ac_word... " >&6; }
21185 if ${ac_cv_path_LDD+:} false; then :
21186   $as_echo_n "(cached) " >&6
21187 else
21188   case $LDD in
21189   [\\/]* | ?:[\\/]*)
21190   ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
21191   ;;
21192   *)
21193   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21194 for as_dir in $PATH
21195 do
21196   IFS=$as_save_IFS
21197   test -z "$as_dir" && as_dir=.
21198     for ac_exec_ext in '' $ac_executable_extensions; do
21199   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21200     ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
21201     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21202     break 2
21203   fi
21204 done
21205   done
21206 IFS=$as_save_IFS
21207 
21208   ;;
21209 esac
21210 fi
21211 LDD=$ac_cv_path_LDD
21212 if test -n "$LDD"; then
21213   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
21214 $as_echo "$LDD" >&6; }
21215 else
21216   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21217 $as_echo "no" >&6; }
21218 fi
21219 
21220 
21221   test -n "$LDD" && break
21222 done
21223 
21224     else
21225       # If it succeeded, then it was overridden by the user. We will use it
21226       # for the tool.
21227 
21228       # First remove it from the list of overridden variables, so we can test
21229       # for unknown variables in the end.
21230       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
21231 
21232       # Check if we try to supply an empty value
21233       if test "x$LDD" = x; then
21234         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool LDD= (no value)" >&5
21235 $as_echo "$as_me: Setting user supplied tool LDD= (no value)" >&6;}
21236         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LDD" >&5
21237 $as_echo_n "checking for LDD... " >&6; }
21238         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
21239 $as_echo "disabled" >&6; }
21240       else
21241         # Check if the provided tool contains a complete path.
21242         tool_specified="$LDD"
21243         tool_basename="${tool_specified##*/}"
21244         if test "x$tool_basename" = "x$tool_specified"; then
21245           # A command without a complete path is provided, search $PATH.
21246           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LDD=$tool_basename" >&5
21247 $as_echo "$as_me: Will search for user supplied tool LDD=$tool_basename" >&6;}
21248           # Extract the first word of "$tool_basename", so it can be a program name with args.
21249 set dummy $tool_basename; ac_word=$2
21250 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21251 $as_echo_n "checking for $ac_word... " >&6; }
21252 if ${ac_cv_path_LDD+:} false; then :
21253   $as_echo_n "(cached) " >&6
21254 else
21255   case $LDD in
21256   [\\/]* | ?:[\\/]*)
21257   ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
21258   ;;
21259   *)
21260   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21261 for as_dir in $PATH
21262 do
21263   IFS=$as_save_IFS
21264   test -z "$as_dir" && as_dir=.
21265     for ac_exec_ext in '' $ac_executable_extensions; do
21266   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21267     ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
21268     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21269     break 2
21270   fi
21271 done
21272   done
21273 IFS=$as_save_IFS
21274 
21275   ;;
21276 esac
21277 fi
21278 LDD=$ac_cv_path_LDD
21279 if test -n "$LDD"; then
21280   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
21281 $as_echo "$LDD" >&6; }
21282 else
21283   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21284 $as_echo "no" >&6; }
21285 fi
21286 
21287 
21288           if test "x$LDD" = x; then
21289             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
21290           fi
21291         else
21292           # Otherwise we believe it is a complete path. Use it as it is.
21293           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LDD=$tool_specified" >&5
21294 $as_echo "$as_me: Will use user supplied tool LDD=$tool_specified" >&6;}
21295           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LDD" >&5
21296 $as_echo_n "checking for LDD... " >&6; }
21297           if test ! -x "$tool_specified"; then
21298             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
21299 $as_echo "not found" >&6; }
21300             as_fn_error $? "User supplied tool LDD=$tool_specified does not exist or is not executable" "$LINENO" 5
21301           fi
21302           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
21303 $as_echo "$tool_specified" >&6; }
21304         fi
21305       fi
21306     fi
21307 
21308   fi
21309 
21310 
21311   if test "x$LDD" = "x"; then
21312     # List shared lib dependencies is used for
21313     # debug output and checking for forbidden dependencies.
21314     # We can build without it.
21315     LDD="true"
21316   fi
21317 
21318 
21319   # Publish this variable in the help.
21320 
21321 
21322   if [ -z "${OTOOL+x}" ]; then
21323     # The variable is not set by user, try to locate tool using the code snippet
21324     for ac_prog in otool
21325 do
21326   # Extract the first word of "$ac_prog", so it can be a program name with args.
21327 set dummy $ac_prog; ac_word=$2
21328 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21329 $as_echo_n "checking for $ac_word... " >&6; }
21330 if ${ac_cv_path_OTOOL+:} false; then :
21331   $as_echo_n "(cached) " >&6
21332 else
21333   case $OTOOL in
21334   [\\/]* | ?:[\\/]*)
21335   ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
21336   ;;
21337   *)
21338   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21339 for as_dir in $PATH
21340 do
21341   IFS=$as_save_IFS
21342   test -z "$as_dir" && as_dir=.
21343     for ac_exec_ext in '' $ac_executable_extensions; do
21344   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21345     ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
21346     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21347     break 2
21348   fi
21349 done
21350   done
21351 IFS=$as_save_IFS
21352 
21353   ;;
21354 esac
21355 fi
21356 OTOOL=$ac_cv_path_OTOOL
21357 if test -n "$OTOOL"; then
21358   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
21359 $as_echo "$OTOOL" >&6; }
21360 else
21361   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21362 $as_echo "no" >&6; }
21363 fi
21364 
21365 
21366   test -n "$OTOOL" && break
21367 done
21368 
21369   else
21370     # The variable is set, but is it from the command line or the environment?
21371 
21372     # Try to remove the string !OTOOL! from our list.
21373     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!OTOOL!/}
21374     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
21375       # If it failed, the variable was not from the command line. Ignore it,
21376       # but warn the user (except for BASH, which is always set by the calling BASH).
21377       if test "xOTOOL" != xBASH; then
21378         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of OTOOL from the environment. Use command line variables instead." >&5
21379 $as_echo "$as_me: WARNING: Ignoring value of OTOOL from the environment. Use command line variables instead." >&2;}
21380       fi
21381       # Try to locate tool using the code snippet
21382       for ac_prog in otool
21383 do
21384   # Extract the first word of "$ac_prog", so it can be a program name with args.
21385 set dummy $ac_prog; ac_word=$2
21386 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21387 $as_echo_n "checking for $ac_word... " >&6; }
21388 if ${ac_cv_path_OTOOL+:} false; then :
21389   $as_echo_n "(cached) " >&6
21390 else
21391   case $OTOOL in
21392   [\\/]* | ?:[\\/]*)
21393   ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
21394   ;;
21395   *)
21396   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21397 for as_dir in $PATH
21398 do
21399   IFS=$as_save_IFS
21400   test -z "$as_dir" && as_dir=.
21401     for ac_exec_ext in '' $ac_executable_extensions; do
21402   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21403     ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
21404     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21405     break 2
21406   fi
21407 done
21408   done
21409 IFS=$as_save_IFS
21410 
21411   ;;
21412 esac
21413 fi
21414 OTOOL=$ac_cv_path_OTOOL
21415 if test -n "$OTOOL"; then
21416   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
21417 $as_echo "$OTOOL" >&6; }
21418 else
21419   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21420 $as_echo "no" >&6; }
21421 fi
21422 
21423 
21424   test -n "$OTOOL" && break
21425 done
21426 
21427     else
21428       # If it succeeded, then it was overridden by the user. We will use it
21429       # for the tool.
21430 
21431       # First remove it from the list of overridden variables, so we can test
21432       # for unknown variables in the end.
21433       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
21434 
21435       # Check if we try to supply an empty value
21436       if test "x$OTOOL" = x; then
21437         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool OTOOL= (no value)" >&5
21438 $as_echo "$as_me: Setting user supplied tool OTOOL= (no value)" >&6;}
21439         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for OTOOL" >&5
21440 $as_echo_n "checking for OTOOL... " >&6; }
21441         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
21442 $as_echo "disabled" >&6; }
21443       else
21444         # Check if the provided tool contains a complete path.
21445         tool_specified="$OTOOL"
21446         tool_basename="${tool_specified##*/}"
21447         if test "x$tool_basename" = "x$tool_specified"; then
21448           # A command without a complete path is provided, search $PATH.
21449           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool OTOOL=$tool_basename" >&5
21450 $as_echo "$as_me: Will search for user supplied tool OTOOL=$tool_basename" >&6;}
21451           # Extract the first word of "$tool_basename", so it can be a program name with args.
21452 set dummy $tool_basename; ac_word=$2
21453 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21454 $as_echo_n "checking for $ac_word... " >&6; }
21455 if ${ac_cv_path_OTOOL+:} false; then :
21456   $as_echo_n "(cached) " >&6
21457 else
21458   case $OTOOL in
21459   [\\/]* | ?:[\\/]*)
21460   ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
21461   ;;
21462   *)
21463   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21464 for as_dir in $PATH
21465 do
21466   IFS=$as_save_IFS
21467   test -z "$as_dir" && as_dir=.
21468     for ac_exec_ext in '' $ac_executable_extensions; do
21469   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21470     ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
21471     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21472     break 2
21473   fi
21474 done
21475   done
21476 IFS=$as_save_IFS
21477 
21478   ;;
21479 esac
21480 fi
21481 OTOOL=$ac_cv_path_OTOOL
21482 if test -n "$OTOOL"; then
21483   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
21484 $as_echo "$OTOOL" >&6; }
21485 else
21486   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21487 $as_echo "no" >&6; }
21488 fi
21489 
21490 
21491           if test "x$OTOOL" = x; then
21492             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
21493           fi
21494         else
21495           # Otherwise we believe it is a complete path. Use it as it is.
21496           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool OTOOL=$tool_specified" >&5
21497 $as_echo "$as_me: Will use user supplied tool OTOOL=$tool_specified" >&6;}
21498           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for OTOOL" >&5
21499 $as_echo_n "checking for OTOOL... " >&6; }
21500           if test ! -x "$tool_specified"; then
21501             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
21502 $as_echo "not found" >&6; }
21503             as_fn_error $? "User supplied tool OTOOL=$tool_specified does not exist or is not executable" "$LINENO" 5
21504           fi
21505           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
21506 $as_echo "$tool_specified" >&6; }
21507         fi
21508       fi
21509     fi
21510 
21511   fi
21512 
21513 
21514   if test "x$OTOOL" = "x"; then
21515     OTOOL="true"
21516   fi
21517 
21518 
21519   # Publish this variable in the help.
21520 
21521 
21522   if [ -z "${READELF+x}" ]; then
21523     # The variable is not set by user, try to locate tool using the code snippet
21524     for ac_prog in greadelf readelf
21525 do
21526   # Extract the first word of "$ac_prog", so it can be a program name with args.
21527 set dummy $ac_prog; ac_word=$2
21528 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21529 $as_echo_n "checking for $ac_word... " >&6; }
21530 if ${ac_cv_path_READELF+:} false; then :
21531   $as_echo_n "(cached) " >&6
21532 else
21533   case $READELF in
21534   [\\/]* | ?:[\\/]*)
21535   ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
21536   ;;
21537   *)
21538   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21539 for as_dir in $PATH
21540 do
21541   IFS=$as_save_IFS
21542   test -z "$as_dir" && as_dir=.
21543     for ac_exec_ext in '' $ac_executable_extensions; do
21544   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21545     ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
21546     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21547     break 2
21548   fi
21549 done
21550   done
21551 IFS=$as_save_IFS
21552 
21553   ;;
21554 esac
21555 fi
21556 READELF=$ac_cv_path_READELF
21557 if test -n "$READELF"; then
21558   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
21559 $as_echo "$READELF" >&6; }
21560 else
21561   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21562 $as_echo "no" >&6; }
21563 fi
21564 
21565 
21566   test -n "$READELF" && break
21567 done
21568 
21569   else
21570     # The variable is set, but is it from the command line or the environment?
21571 
21572     # Try to remove the string !READELF! from our list.
21573     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!READELF!/}
21574     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
21575       # If it failed, the variable was not from the command line. Ignore it,
21576       # but warn the user (except for BASH, which is always set by the calling BASH).
21577       if test "xREADELF" != xBASH; then
21578         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of READELF from the environment. Use command line variables instead." >&5
21579 $as_echo "$as_me: WARNING: Ignoring value of READELF from the environment. Use command line variables instead." >&2;}
21580       fi
21581       # Try to locate tool using the code snippet
21582       for ac_prog in greadelf readelf
21583 do
21584   # Extract the first word of "$ac_prog", so it can be a program name with args.
21585 set dummy $ac_prog; ac_word=$2
21586 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21587 $as_echo_n "checking for $ac_word... " >&6; }
21588 if ${ac_cv_path_READELF+:} false; then :
21589   $as_echo_n "(cached) " >&6
21590 else
21591   case $READELF in
21592   [\\/]* | ?:[\\/]*)
21593   ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
21594   ;;
21595   *)
21596   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21597 for as_dir in $PATH
21598 do
21599   IFS=$as_save_IFS
21600   test -z "$as_dir" && as_dir=.
21601     for ac_exec_ext in '' $ac_executable_extensions; do
21602   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21603     ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
21604     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21605     break 2
21606   fi
21607 done
21608   done
21609 IFS=$as_save_IFS
21610 
21611   ;;
21612 esac
21613 fi
21614 READELF=$ac_cv_path_READELF
21615 if test -n "$READELF"; then
21616   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
21617 $as_echo "$READELF" >&6; }
21618 else
21619   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21620 $as_echo "no" >&6; }
21621 fi
21622 
21623 
21624   test -n "$READELF" && break
21625 done
21626 
21627     else
21628       # If it succeeded, then it was overridden by the user. We will use it
21629       # for the tool.
21630 
21631       # First remove it from the list of overridden variables, so we can test
21632       # for unknown variables in the end.
21633       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
21634 
21635       # Check if we try to supply an empty value
21636       if test "x$READELF" = x; then
21637         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool READELF= (no value)" >&5
21638 $as_echo "$as_me: Setting user supplied tool READELF= (no value)" >&6;}
21639         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READELF" >&5
21640 $as_echo_n "checking for READELF... " >&6; }
21641         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
21642 $as_echo "disabled" >&6; }
21643       else
21644         # Check if the provided tool contains a complete path.
21645         tool_specified="$READELF"
21646         tool_basename="${tool_specified##*/}"
21647         if test "x$tool_basename" = "x$tool_specified"; then
21648           # A command without a complete path is provided, search $PATH.
21649           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool READELF=$tool_basename" >&5
21650 $as_echo "$as_me: Will search for user supplied tool READELF=$tool_basename" >&6;}
21651           # Extract the first word of "$tool_basename", so it can be a program name with args.
21652 set dummy $tool_basename; ac_word=$2
21653 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21654 $as_echo_n "checking for $ac_word... " >&6; }
21655 if ${ac_cv_path_READELF+:} false; then :
21656   $as_echo_n "(cached) " >&6
21657 else
21658   case $READELF in
21659   [\\/]* | ?:[\\/]*)
21660   ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
21661   ;;
21662   *)
21663   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21664 for as_dir in $PATH
21665 do
21666   IFS=$as_save_IFS
21667   test -z "$as_dir" && as_dir=.
21668     for ac_exec_ext in '' $ac_executable_extensions; do
21669   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21670     ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
21671     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21672     break 2
21673   fi
21674 done
21675   done
21676 IFS=$as_save_IFS
21677 
21678   ;;
21679 esac
21680 fi
21681 READELF=$ac_cv_path_READELF
21682 if test -n "$READELF"; then
21683   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
21684 $as_echo "$READELF" >&6; }
21685 else
21686   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21687 $as_echo "no" >&6; }
21688 fi
21689 
21690 
21691           if test "x$READELF" = x; then
21692             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
21693           fi
21694         else
21695           # Otherwise we believe it is a complete path. Use it as it is.
21696           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool READELF=$tool_specified" >&5
21697 $as_echo "$as_me: Will use user supplied tool READELF=$tool_specified" >&6;}
21698           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READELF" >&5
21699 $as_echo_n "checking for READELF... " >&6; }
21700           if test ! -x "$tool_specified"; then
21701             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
21702 $as_echo "not found" >&6; }
21703             as_fn_error $? "User supplied tool READELF=$tool_specified does not exist or is not executable" "$LINENO" 5
21704           fi
21705           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
21706 $as_echo "$tool_specified" >&6; }
21707         fi
21708       fi
21709     fi
21710 
21711   fi
21712 
21713 
21714 
21715 
21716   # Publish this variable in the help.
21717 
21718 
21719   if [ -z "${HG+x}" ]; then
21720     # The variable is not set by user, try to locate tool using the code snippet
21721     for ac_prog in hg
21722 do
21723   # Extract the first word of "$ac_prog", so it can be a program name with args.
21724 set dummy $ac_prog; ac_word=$2
21725 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21726 $as_echo_n "checking for $ac_word... " >&6; }
21727 if ${ac_cv_path_HG+:} false; then :
21728   $as_echo_n "(cached) " >&6
21729 else
21730   case $HG in
21731   [\\/]* | ?:[\\/]*)
21732   ac_cv_path_HG="$HG" # Let the user override the test with a path.
21733   ;;
21734   *)
21735   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21736 for as_dir in $PATH
21737 do
21738   IFS=$as_save_IFS
21739   test -z "$as_dir" && as_dir=.
21740     for ac_exec_ext in '' $ac_executable_extensions; do
21741   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21742     ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
21743     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21744     break 2
21745   fi
21746 done
21747   done
21748 IFS=$as_save_IFS
21749 
21750   ;;
21751 esac
21752 fi
21753 HG=$ac_cv_path_HG
21754 if test -n "$HG"; then
21755   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
21756 $as_echo "$HG" >&6; }
21757 else
21758   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21759 $as_echo "no" >&6; }
21760 fi
21761 
21762 
21763   test -n "$HG" && break
21764 done
21765 
21766   else
21767     # The variable is set, but is it from the command line or the environment?
21768 
21769     # Try to remove the string !HG! from our list.
21770     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!HG!/}
21771     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
21772       # If it failed, the variable was not from the command line. Ignore it,
21773       # but warn the user (except for BASH, which is always set by the calling BASH).
21774       if test "xHG" != xBASH; then
21775         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of HG from the environment. Use command line variables instead." >&5
21776 $as_echo "$as_me: WARNING: Ignoring value of HG from the environment. Use command line variables instead." >&2;}
21777       fi
21778       # Try to locate tool using the code snippet
21779       for ac_prog in hg
21780 do
21781   # Extract the first word of "$ac_prog", so it can be a program name with args.
21782 set dummy $ac_prog; ac_word=$2
21783 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21784 $as_echo_n "checking for $ac_word... " >&6; }
21785 if ${ac_cv_path_HG+:} false; then :
21786   $as_echo_n "(cached) " >&6
21787 else
21788   case $HG in
21789   [\\/]* | ?:[\\/]*)
21790   ac_cv_path_HG="$HG" # Let the user override the test with a path.
21791   ;;
21792   *)
21793   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21794 for as_dir in $PATH
21795 do
21796   IFS=$as_save_IFS
21797   test -z "$as_dir" && as_dir=.
21798     for ac_exec_ext in '' $ac_executable_extensions; do
21799   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21800     ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
21801     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21802     break 2
21803   fi
21804 done
21805   done
21806 IFS=$as_save_IFS
21807 
21808   ;;
21809 esac
21810 fi
21811 HG=$ac_cv_path_HG
21812 if test -n "$HG"; then
21813   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
21814 $as_echo "$HG" >&6; }
21815 else
21816   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21817 $as_echo "no" >&6; }
21818 fi
21819 
21820 
21821   test -n "$HG" && break
21822 done
21823 
21824     else
21825       # If it succeeded, then it was overridden by the user. We will use it
21826       # for the tool.
21827 
21828       # First remove it from the list of overridden variables, so we can test
21829       # for unknown variables in the end.
21830       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
21831 
21832       # Check if we try to supply an empty value
21833       if test "x$HG" = x; then
21834         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool HG= (no value)" >&5
21835 $as_echo "$as_me: Setting user supplied tool HG= (no value)" >&6;}
21836         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HG" >&5
21837 $as_echo_n "checking for HG... " >&6; }
21838         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
21839 $as_echo "disabled" >&6; }
21840       else
21841         # Check if the provided tool contains a complete path.
21842         tool_specified="$HG"
21843         tool_basename="${tool_specified##*/}"
21844         if test "x$tool_basename" = "x$tool_specified"; then
21845           # A command without a complete path is provided, search $PATH.
21846           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool HG=$tool_basename" >&5
21847 $as_echo "$as_me: Will search for user supplied tool HG=$tool_basename" >&6;}
21848           # Extract the first word of "$tool_basename", so it can be a program name with args.
21849 set dummy $tool_basename; ac_word=$2
21850 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21851 $as_echo_n "checking for $ac_word... " >&6; }
21852 if ${ac_cv_path_HG+:} false; then :
21853   $as_echo_n "(cached) " >&6
21854 else
21855   case $HG in
21856   [\\/]* | ?:[\\/]*)
21857   ac_cv_path_HG="$HG" # Let the user override the test with a path.
21858   ;;
21859   *)
21860   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21861 for as_dir in $PATH
21862 do
21863   IFS=$as_save_IFS
21864   test -z "$as_dir" && as_dir=.
21865     for ac_exec_ext in '' $ac_executable_extensions; do
21866   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21867     ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
21868     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21869     break 2
21870   fi
21871 done
21872   done
21873 IFS=$as_save_IFS
21874 
21875   ;;
21876 esac
21877 fi
21878 HG=$ac_cv_path_HG
21879 if test -n "$HG"; then
21880   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
21881 $as_echo "$HG" >&6; }
21882 else
21883   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21884 $as_echo "no" >&6; }
21885 fi
21886 
21887 
21888           if test "x$HG" = x; then
21889             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
21890           fi
21891         else
21892           # Otherwise we believe it is a complete path. Use it as it is.
21893           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool HG=$tool_specified" >&5
21894 $as_echo "$as_me: Will use user supplied tool HG=$tool_specified" >&6;}
21895           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HG" >&5
21896 $as_echo_n "checking for HG... " >&6; }
21897           if test ! -x "$tool_specified"; then
21898             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
21899 $as_echo "not found" >&6; }
21900             as_fn_error $? "User supplied tool HG=$tool_specified does not exist or is not executable" "$LINENO" 5
21901           fi
21902           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
21903 $as_echo "$tool_specified" >&6; }
21904         fi
21905       fi
21906     fi
21907 
21908   fi
21909 
21910 
21911 
21912 
21913   # Publish this variable in the help.
21914 
21915 
21916   if [ -z "${STAT+x}" ]; then
21917     # The variable is not set by user, try to locate tool using the code snippet
21918     for ac_prog in stat
21919 do
21920   # Extract the first word of "$ac_prog", so it can be a program name with args.
21921 set dummy $ac_prog; ac_word=$2
21922 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21923 $as_echo_n "checking for $ac_word... " >&6; }
21924 if ${ac_cv_path_STAT+:} false; then :
21925   $as_echo_n "(cached) " >&6
21926 else
21927   case $STAT in
21928   [\\/]* | ?:[\\/]*)
21929   ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
21930   ;;
21931   *)
21932   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21933 for as_dir in $PATH
21934 do
21935   IFS=$as_save_IFS
21936   test -z "$as_dir" && as_dir=.
21937     for ac_exec_ext in '' $ac_executable_extensions; do
21938   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21939     ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
21940     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21941     break 2
21942   fi
21943 done
21944   done
21945 IFS=$as_save_IFS
21946 
21947   ;;
21948 esac
21949 fi
21950 STAT=$ac_cv_path_STAT
21951 if test -n "$STAT"; then
21952   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
21953 $as_echo "$STAT" >&6; }
21954 else
21955   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21956 $as_echo "no" >&6; }
21957 fi
21958 
21959 
21960   test -n "$STAT" && break
21961 done
21962 
21963   else
21964     # The variable is set, but is it from the command line or the environment?
21965 
21966     # Try to remove the string !STAT! from our list.
21967     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!STAT!/}
21968     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
21969       # If it failed, the variable was not from the command line. Ignore it,
21970       # but warn the user (except for BASH, which is always set by the calling BASH).
21971       if test "xSTAT" != xBASH; then
21972         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of STAT from the environment. Use command line variables instead." >&5
21973 $as_echo "$as_me: WARNING: Ignoring value of STAT from the environment. Use command line variables instead." >&2;}
21974       fi
21975       # Try to locate tool using the code snippet
21976       for ac_prog in stat
21977 do
21978   # Extract the first word of "$ac_prog", so it can be a program name with args.
21979 set dummy $ac_prog; ac_word=$2
21980 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21981 $as_echo_n "checking for $ac_word... " >&6; }
21982 if ${ac_cv_path_STAT+:} false; then :
21983   $as_echo_n "(cached) " >&6
21984 else
21985   case $STAT in
21986   [\\/]* | ?:[\\/]*)
21987   ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
21988   ;;
21989   *)
21990   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21991 for as_dir in $PATH
21992 do
21993   IFS=$as_save_IFS
21994   test -z "$as_dir" && as_dir=.
21995     for ac_exec_ext in '' $ac_executable_extensions; do
21996   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21997     ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
21998     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21999     break 2
22000   fi
22001 done
22002   done
22003 IFS=$as_save_IFS
22004 
22005   ;;
22006 esac
22007 fi
22008 STAT=$ac_cv_path_STAT
22009 if test -n "$STAT"; then
22010   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
22011 $as_echo "$STAT" >&6; }
22012 else
22013   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22014 $as_echo "no" >&6; }
22015 fi
22016 
22017 
22018   test -n "$STAT" && break
22019 done
22020 
22021     else
22022       # If it succeeded, then it was overridden by the user. We will use it
22023       # for the tool.
22024 
22025       # First remove it from the list of overridden variables, so we can test
22026       # for unknown variables in the end.
22027       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
22028 
22029       # Check if we try to supply an empty value
22030       if test "x$STAT" = x; then
22031         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool STAT= (no value)" >&5
22032 $as_echo "$as_me: Setting user supplied tool STAT= (no value)" >&6;}
22033         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for STAT" >&5
22034 $as_echo_n "checking for STAT... " >&6; }
22035         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
22036 $as_echo "disabled" >&6; }
22037       else
22038         # Check if the provided tool contains a complete path.
22039         tool_specified="$STAT"
22040         tool_basename="${tool_specified##*/}"
22041         if test "x$tool_basename" = "x$tool_specified"; then
22042           # A command without a complete path is provided, search $PATH.
22043           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool STAT=$tool_basename" >&5
22044 $as_echo "$as_me: Will search for user supplied tool STAT=$tool_basename" >&6;}
22045           # Extract the first word of "$tool_basename", so it can be a program name with args.
22046 set dummy $tool_basename; ac_word=$2
22047 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22048 $as_echo_n "checking for $ac_word... " >&6; }
22049 if ${ac_cv_path_STAT+:} false; then :
22050   $as_echo_n "(cached) " >&6
22051 else
22052   case $STAT in
22053   [\\/]* | ?:[\\/]*)
22054   ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
22055   ;;
22056   *)
22057   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22058 for as_dir in $PATH
22059 do
22060   IFS=$as_save_IFS
22061   test -z "$as_dir" && as_dir=.
22062     for ac_exec_ext in '' $ac_executable_extensions; do
22063   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22064     ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
22065     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22066     break 2
22067   fi
22068 done
22069   done
22070 IFS=$as_save_IFS
22071 
22072   ;;
22073 esac
22074 fi
22075 STAT=$ac_cv_path_STAT
22076 if test -n "$STAT"; then
22077   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
22078 $as_echo "$STAT" >&6; }
22079 else
22080   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22081 $as_echo "no" >&6; }
22082 fi
22083 
22084 
22085           if test "x$STAT" = x; then
22086             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
22087           fi
22088         else
22089           # Otherwise we believe it is a complete path. Use it as it is.
22090           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool STAT=$tool_specified" >&5
22091 $as_echo "$as_me: Will use user supplied tool STAT=$tool_specified" >&6;}
22092           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for STAT" >&5
22093 $as_echo_n "checking for STAT... " >&6; }
22094           if test ! -x "$tool_specified"; then
22095             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
22096 $as_echo "not found" >&6; }
22097             as_fn_error $? "User supplied tool STAT=$tool_specified does not exist or is not executable" "$LINENO" 5
22098           fi
22099           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
22100 $as_echo "$tool_specified" >&6; }
22101         fi
22102       fi
22103     fi
22104 
22105   fi
22106 
22107 
22108 
22109 
22110   # Publish this variable in the help.
22111 
22112 
22113   if [ -z "${TIME+x}" ]; then
22114     # The variable is not set by user, try to locate tool using the code snippet
22115     for ac_prog in time
22116 do
22117   # Extract the first word of "$ac_prog", so it can be a program name with args.
22118 set dummy $ac_prog; ac_word=$2
22119 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22120 $as_echo_n "checking for $ac_word... " >&6; }
22121 if ${ac_cv_path_TIME+:} false; then :
22122   $as_echo_n "(cached) " >&6
22123 else
22124   case $TIME in
22125   [\\/]* | ?:[\\/]*)
22126   ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
22127   ;;
22128   *)
22129   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22130 for as_dir in $PATH
22131 do
22132   IFS=$as_save_IFS
22133   test -z "$as_dir" && as_dir=.
22134     for ac_exec_ext in '' $ac_executable_extensions; do
22135   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22136     ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
22137     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22138     break 2
22139   fi
22140 done
22141   done
22142 IFS=$as_save_IFS
22143 
22144   ;;
22145 esac
22146 fi
22147 TIME=$ac_cv_path_TIME
22148 if test -n "$TIME"; then
22149   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
22150 $as_echo "$TIME" >&6; }
22151 else
22152   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22153 $as_echo "no" >&6; }
22154 fi
22155 
22156 
22157   test -n "$TIME" && break
22158 done
22159 
22160   else
22161     # The variable is set, but is it from the command line or the environment?
22162 
22163     # Try to remove the string !TIME! from our list.
22164     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TIME!/}
22165     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
22166       # If it failed, the variable was not from the command line. Ignore it,
22167       # but warn the user (except for BASH, which is always set by the calling BASH).
22168       if test "xTIME" != xBASH; then
22169         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TIME from the environment. Use command line variables instead." >&5
22170 $as_echo "$as_me: WARNING: Ignoring value of TIME from the environment. Use command line variables instead." >&2;}
22171       fi
22172       # Try to locate tool using the code snippet
22173       for ac_prog in time
22174 do
22175   # Extract the first word of "$ac_prog", so it can be a program name with args.
22176 set dummy $ac_prog; ac_word=$2
22177 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22178 $as_echo_n "checking for $ac_word... " >&6; }
22179 if ${ac_cv_path_TIME+:} false; then :
22180   $as_echo_n "(cached) " >&6
22181 else
22182   case $TIME in
22183   [\\/]* | ?:[\\/]*)
22184   ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
22185   ;;
22186   *)
22187   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22188 for as_dir in $PATH
22189 do
22190   IFS=$as_save_IFS
22191   test -z "$as_dir" && as_dir=.
22192     for ac_exec_ext in '' $ac_executable_extensions; do
22193   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22194     ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
22195     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22196     break 2
22197   fi
22198 done
22199   done
22200 IFS=$as_save_IFS
22201 
22202   ;;
22203 esac
22204 fi
22205 TIME=$ac_cv_path_TIME
22206 if test -n "$TIME"; then
22207   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
22208 $as_echo "$TIME" >&6; }
22209 else
22210   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22211 $as_echo "no" >&6; }
22212 fi
22213 
22214 
22215   test -n "$TIME" && break
22216 done
22217 
22218     else
22219       # If it succeeded, then it was overridden by the user. We will use it
22220       # for the tool.
22221 
22222       # First remove it from the list of overridden variables, so we can test
22223       # for unknown variables in the end.
22224       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
22225 
22226       # Check if we try to supply an empty value
22227       if test "x$TIME" = x; then
22228         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool TIME= (no value)" >&5
22229 $as_echo "$as_me: Setting user supplied tool TIME= (no value)" >&6;}
22230         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TIME" >&5
22231 $as_echo_n "checking for TIME... " >&6; }
22232         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
22233 $as_echo "disabled" >&6; }
22234       else
22235         # Check if the provided tool contains a complete path.
22236         tool_specified="$TIME"
22237         tool_basename="${tool_specified##*/}"
22238         if test "x$tool_basename" = "x$tool_specified"; then
22239           # A command without a complete path is provided, search $PATH.
22240           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TIME=$tool_basename" >&5
22241 $as_echo "$as_me: Will search for user supplied tool TIME=$tool_basename" >&6;}
22242           # Extract the first word of "$tool_basename", so it can be a program name with args.
22243 set dummy $tool_basename; ac_word=$2
22244 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22245 $as_echo_n "checking for $ac_word... " >&6; }
22246 if ${ac_cv_path_TIME+:} false; then :
22247   $as_echo_n "(cached) " >&6
22248 else
22249   case $TIME in
22250   [\\/]* | ?:[\\/]*)
22251   ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
22252   ;;
22253   *)
22254   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22255 for as_dir in $PATH
22256 do
22257   IFS=$as_save_IFS
22258   test -z "$as_dir" && as_dir=.
22259     for ac_exec_ext in '' $ac_executable_extensions; do
22260   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22261     ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
22262     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22263     break 2
22264   fi
22265 done
22266   done
22267 IFS=$as_save_IFS
22268 
22269   ;;
22270 esac
22271 fi
22272 TIME=$ac_cv_path_TIME
22273 if test -n "$TIME"; then
22274   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
22275 $as_echo "$TIME" >&6; }
22276 else
22277   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22278 $as_echo "no" >&6; }
22279 fi
22280 
22281 
22282           if test "x$TIME" = x; then
22283             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
22284           fi
22285         else
22286           # Otherwise we believe it is a complete path. Use it as it is.
22287           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TIME=$tool_specified" >&5
22288 $as_echo "$as_me: Will use user supplied tool TIME=$tool_specified" >&6;}
22289           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TIME" >&5
22290 $as_echo_n "checking for TIME... " >&6; }
22291           if test ! -x "$tool_specified"; then
22292             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
22293 $as_echo "not found" >&6; }
22294             as_fn_error $? "User supplied tool TIME=$tool_specified does not exist or is not executable" "$LINENO" 5
22295           fi
22296           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
22297 $as_echo "$tool_specified" >&6; }
22298         fi
22299       fi
22300     fi
22301 
22302   fi
22303 
22304 
22305 
22306 
22307   # Publish this variable in the help.
22308 
22309 
22310   if [ -z "${DTRACE+x}" ]; then
22311     # The variable is not set by user, try to locate tool using the code snippet
22312     for ac_prog in dtrace
22313 do
22314   # Extract the first word of "$ac_prog", so it can be a program name with args.
22315 set dummy $ac_prog; ac_word=$2
22316 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22317 $as_echo_n "checking for $ac_word... " >&6; }
22318 if ${ac_cv_path_DTRACE+:} false; then :
22319   $as_echo_n "(cached) " >&6
22320 else
22321   case $DTRACE in
22322   [\\/]* | ?:[\\/]*)
22323   ac_cv_path_DTRACE="$DTRACE" # Let the user override the test with a path.
22324   ;;
22325   *)
22326   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22327 for as_dir in $PATH
22328 do
22329   IFS=$as_save_IFS
22330   test -z "$as_dir" && as_dir=.
22331     for ac_exec_ext in '' $ac_executable_extensions; do
22332   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22333     ac_cv_path_DTRACE="$as_dir/$ac_word$ac_exec_ext"
22334     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22335     break 2
22336   fi
22337 done
22338   done
22339 IFS=$as_save_IFS
22340 
22341   ;;
22342 esac
22343 fi
22344 DTRACE=$ac_cv_path_DTRACE
22345 if test -n "$DTRACE"; then
22346   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DTRACE" >&5
22347 $as_echo "$DTRACE" >&6; }
22348 else
22349   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22350 $as_echo "no" >&6; }
22351 fi
22352 
22353 
22354   test -n "$DTRACE" && break
22355 done
22356 
22357   else
22358     # The variable is set, but is it from the command line or the environment?
22359 
22360     # Try to remove the string !DTRACE! from our list.
22361     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DTRACE!/}
22362     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
22363       # If it failed, the variable was not from the command line. Ignore it,
22364       # but warn the user (except for BASH, which is always set by the calling BASH).
22365       if test "xDTRACE" != xBASH; then
22366         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DTRACE from the environment. Use command line variables instead." >&5
22367 $as_echo "$as_me: WARNING: Ignoring value of DTRACE from the environment. Use command line variables instead." >&2;}
22368       fi
22369       # Try to locate tool using the code snippet
22370       for ac_prog in dtrace
22371 do
22372   # Extract the first word of "$ac_prog", so it can be a program name with args.
22373 set dummy $ac_prog; ac_word=$2
22374 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22375 $as_echo_n "checking for $ac_word... " >&6; }
22376 if ${ac_cv_path_DTRACE+:} false; then :
22377   $as_echo_n "(cached) " >&6
22378 else
22379   case $DTRACE in
22380   [\\/]* | ?:[\\/]*)
22381   ac_cv_path_DTRACE="$DTRACE" # Let the user override the test with a path.
22382   ;;
22383   *)
22384   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22385 for as_dir in $PATH
22386 do
22387   IFS=$as_save_IFS
22388   test -z "$as_dir" && as_dir=.
22389     for ac_exec_ext in '' $ac_executable_extensions; do
22390   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22391     ac_cv_path_DTRACE="$as_dir/$ac_word$ac_exec_ext"
22392     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22393     break 2
22394   fi
22395 done
22396   done
22397 IFS=$as_save_IFS
22398 
22399   ;;
22400 esac
22401 fi
22402 DTRACE=$ac_cv_path_DTRACE
22403 if test -n "$DTRACE"; then
22404   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DTRACE" >&5
22405 $as_echo "$DTRACE" >&6; }
22406 else
22407   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22408 $as_echo "no" >&6; }
22409 fi
22410 
22411 
22412   test -n "$DTRACE" && break
22413 done
22414 
22415     else
22416       # If it succeeded, then it was overridden by the user. We will use it
22417       # for the tool.
22418 
22419       # First remove it from the list of overridden variables, so we can test
22420       # for unknown variables in the end.
22421       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
22422 
22423       # Check if we try to supply an empty value
22424       if test "x$DTRACE" = x; then
22425         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool DTRACE= (no value)" >&5
22426 $as_echo "$as_me: Setting user supplied tool DTRACE= (no value)" >&6;}
22427         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DTRACE" >&5
22428 $as_echo_n "checking for DTRACE... " >&6; }
22429         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
22430 $as_echo "disabled" >&6; }
22431       else
22432         # Check if the provided tool contains a complete path.
22433         tool_specified="$DTRACE"
22434         tool_basename="${tool_specified##*/}"
22435         if test "x$tool_basename" = "x$tool_specified"; then
22436           # A command without a complete path is provided, search $PATH.
22437           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DTRACE=$tool_basename" >&5
22438 $as_echo "$as_me: Will search for user supplied tool DTRACE=$tool_basename" >&6;}
22439           # Extract the first word of "$tool_basename", so it can be a program name with args.
22440 set dummy $tool_basename; ac_word=$2
22441 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22442 $as_echo_n "checking for $ac_word... " >&6; }
22443 if ${ac_cv_path_DTRACE+:} false; then :
22444   $as_echo_n "(cached) " >&6
22445 else
22446   case $DTRACE in
22447   [\\/]* | ?:[\\/]*)
22448   ac_cv_path_DTRACE="$DTRACE" # Let the user override the test with a path.
22449   ;;
22450   *)
22451   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22452 for as_dir in $PATH
22453 do
22454   IFS=$as_save_IFS
22455   test -z "$as_dir" && as_dir=.
22456     for ac_exec_ext in '' $ac_executable_extensions; do
22457   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22458     ac_cv_path_DTRACE="$as_dir/$ac_word$ac_exec_ext"
22459     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22460     break 2
22461   fi
22462 done
22463   done
22464 IFS=$as_save_IFS
22465 
22466   ;;
22467 esac
22468 fi
22469 DTRACE=$ac_cv_path_DTRACE
22470 if test -n "$DTRACE"; then
22471   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DTRACE" >&5
22472 $as_echo "$DTRACE" >&6; }
22473 else
22474   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22475 $as_echo "no" >&6; }
22476 fi
22477 
22478 
22479           if test "x$DTRACE" = x; then
22480             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
22481           fi
22482         else
22483           # Otherwise we believe it is a complete path. Use it as it is.
22484           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DTRACE=$tool_specified" >&5
22485 $as_echo "$as_me: Will use user supplied tool DTRACE=$tool_specified" >&6;}
22486           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DTRACE" >&5
22487 $as_echo_n "checking for DTRACE... " >&6; }
22488           if test ! -x "$tool_specified"; then
22489             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
22490 $as_echo "not found" >&6; }
22491             as_fn_error $? "User supplied tool DTRACE=$tool_specified does not exist or is not executable" "$LINENO" 5
22492           fi
22493           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
22494 $as_echo "$tool_specified" >&6; }
22495         fi
22496       fi
22497     fi
22498 
22499   fi
22500 
22501 
22502 
22503 
22504   # Publish this variable in the help.
22505 
22506 
22507   if [ -z "${PATCH+x}" ]; then
22508     # The variable is not set by user, try to locate tool using the code snippet
22509     for ac_prog in gpatch patch
22510 do
22511   # Extract the first word of "$ac_prog", so it can be a program name with args.
22512 set dummy $ac_prog; ac_word=$2
22513 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22514 $as_echo_n "checking for $ac_word... " >&6; }
22515 if ${ac_cv_path_PATCH+:} false; then :
22516   $as_echo_n "(cached) " >&6
22517 else
22518   case $PATCH in
22519   [\\/]* | ?:[\\/]*)
22520   ac_cv_path_PATCH="$PATCH" # Let the user override the test with a path.
22521   ;;
22522   *)
22523   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22524 for as_dir in $PATH
22525 do
22526   IFS=$as_save_IFS
22527   test -z "$as_dir" && as_dir=.
22528     for ac_exec_ext in '' $ac_executable_extensions; do
22529   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22530     ac_cv_path_PATCH="$as_dir/$ac_word$ac_exec_ext"
22531     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22532     break 2
22533   fi
22534 done
22535   done
22536 IFS=$as_save_IFS
22537 
22538   ;;
22539 esac
22540 fi
22541 PATCH=$ac_cv_path_PATCH
22542 if test -n "$PATCH"; then
22543   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PATCH" >&5
22544 $as_echo "$PATCH" >&6; }
22545 else
22546   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22547 $as_echo "no" >&6; }
22548 fi
22549 
22550 
22551   test -n "$PATCH" && break
22552 done
22553 
22554   else
22555     # The variable is set, but is it from the command line or the environment?
22556 
22557     # Try to remove the string !PATCH! from our list.
22558     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!PATCH!/}
22559     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
22560       # If it failed, the variable was not from the command line. Ignore it,
22561       # but warn the user (except for BASH, which is always set by the calling BASH).
22562       if test "xPATCH" != xBASH; then
22563         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of PATCH from the environment. Use command line variables instead." >&5
22564 $as_echo "$as_me: WARNING: Ignoring value of PATCH from the environment. Use command line variables instead." >&2;}
22565       fi
22566       # Try to locate tool using the code snippet
22567       for ac_prog in gpatch patch
22568 do
22569   # Extract the first word of "$ac_prog", so it can be a program name with args.
22570 set dummy $ac_prog; ac_word=$2
22571 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22572 $as_echo_n "checking for $ac_word... " >&6; }
22573 if ${ac_cv_path_PATCH+:} false; then :
22574   $as_echo_n "(cached) " >&6
22575 else
22576   case $PATCH in
22577   [\\/]* | ?:[\\/]*)
22578   ac_cv_path_PATCH="$PATCH" # Let the user override the test with a path.
22579   ;;
22580   *)
22581   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22582 for as_dir in $PATH
22583 do
22584   IFS=$as_save_IFS
22585   test -z "$as_dir" && as_dir=.
22586     for ac_exec_ext in '' $ac_executable_extensions; do
22587   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22588     ac_cv_path_PATCH="$as_dir/$ac_word$ac_exec_ext"
22589     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22590     break 2
22591   fi
22592 done
22593   done
22594 IFS=$as_save_IFS
22595 
22596   ;;
22597 esac
22598 fi
22599 PATCH=$ac_cv_path_PATCH
22600 if test -n "$PATCH"; then
22601   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PATCH" >&5
22602 $as_echo "$PATCH" >&6; }
22603 else
22604   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22605 $as_echo "no" >&6; }
22606 fi
22607 
22608 
22609   test -n "$PATCH" && break
22610 done
22611 
22612     else
22613       # If it succeeded, then it was overridden by the user. We will use it
22614       # for the tool.
22615 
22616       # First remove it from the list of overridden variables, so we can test
22617       # for unknown variables in the end.
22618       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
22619 
22620       # Check if we try to supply an empty value
22621       if test "x$PATCH" = x; then
22622         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool PATCH= (no value)" >&5
22623 $as_echo "$as_me: Setting user supplied tool PATCH= (no value)" >&6;}
22624         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PATCH" >&5
22625 $as_echo_n "checking for PATCH... " >&6; }
22626         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
22627 $as_echo "disabled" >&6; }
22628       else
22629         # Check if the provided tool contains a complete path.
22630         tool_specified="$PATCH"
22631         tool_basename="${tool_specified##*/}"
22632         if test "x$tool_basename" = "x$tool_specified"; then
22633           # A command without a complete path is provided, search $PATH.
22634           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool PATCH=$tool_basename" >&5
22635 $as_echo "$as_me: Will search for user supplied tool PATCH=$tool_basename" >&6;}
22636           # Extract the first word of "$tool_basename", so it can be a program name with args.
22637 set dummy $tool_basename; ac_word=$2
22638 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22639 $as_echo_n "checking for $ac_word... " >&6; }
22640 if ${ac_cv_path_PATCH+:} false; then :
22641   $as_echo_n "(cached) " >&6
22642 else
22643   case $PATCH in
22644   [\\/]* | ?:[\\/]*)
22645   ac_cv_path_PATCH="$PATCH" # Let the user override the test with a path.
22646   ;;
22647   *)
22648   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22649 for as_dir in $PATH
22650 do
22651   IFS=$as_save_IFS
22652   test -z "$as_dir" && as_dir=.
22653     for ac_exec_ext in '' $ac_executable_extensions; do
22654   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22655     ac_cv_path_PATCH="$as_dir/$ac_word$ac_exec_ext"
22656     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22657     break 2
22658   fi
22659 done
22660   done
22661 IFS=$as_save_IFS
22662 
22663   ;;
22664 esac
22665 fi
22666 PATCH=$ac_cv_path_PATCH
22667 if test -n "$PATCH"; then
22668   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PATCH" >&5
22669 $as_echo "$PATCH" >&6; }
22670 else
22671   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22672 $as_echo "no" >&6; }
22673 fi
22674 
22675 
22676           if test "x$PATCH" = x; then
22677             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
22678           fi
22679         else
22680           # Otherwise we believe it is a complete path. Use it as it is.
22681           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool PATCH=$tool_specified" >&5
22682 $as_echo "$as_me: Will use user supplied tool PATCH=$tool_specified" >&6;}
22683           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PATCH" >&5
22684 $as_echo_n "checking for PATCH... " >&6; }
22685           if test ! -x "$tool_specified"; then
22686             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
22687 $as_echo "not found" >&6; }
22688             as_fn_error $? "User supplied tool PATCH=$tool_specified does not exist or is not executable" "$LINENO" 5
22689           fi
22690           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
22691 $as_echo "$tool_specified" >&6; }
22692         fi
22693       fi
22694     fi
22695 
22696   fi
22697 
22698 
22699   # Check if it's GNU time
22700   IS_GNU_TIME=`$TIME --version 2>&1 | $GREP 'GNU time'`
22701   if test "x$IS_GNU_TIME" != x; then
22702     IS_GNU_TIME=yes
22703   else
22704     IS_GNU_TIME=no
22705   fi
22706 
22707 
22708   if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
22709 
22710 
22711 
22712   # Publish this variable in the help.
22713 
22714 
22715   if [ -z "${DSYMUTIL+x}" ]; then
22716     # The variable is not set by user, try to locate tool using the code snippet
22717     for ac_prog in dsymutil
22718 do
22719   # Extract the first word of "$ac_prog", so it can be a program name with args.
22720 set dummy $ac_prog; ac_word=$2
22721 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22722 $as_echo_n "checking for $ac_word... " >&6; }
22723 if ${ac_cv_path_DSYMUTIL+:} false; then :
22724   $as_echo_n "(cached) " >&6
22725 else
22726   case $DSYMUTIL in
22727   [\\/]* | ?:[\\/]*)
22728   ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
22729   ;;
22730   *)
22731   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22732 for as_dir in $PATH
22733 do
22734   IFS=$as_save_IFS
22735   test -z "$as_dir" && as_dir=.
22736     for ac_exec_ext in '' $ac_executable_extensions; do
22737   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22738     ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
22739     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22740     break 2
22741   fi
22742 done
22743   done
22744 IFS=$as_save_IFS
22745 
22746   ;;
22747 esac
22748 fi
22749 DSYMUTIL=$ac_cv_path_DSYMUTIL
22750 if test -n "$DSYMUTIL"; then
22751   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
22752 $as_echo "$DSYMUTIL" >&6; }
22753 else
22754   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22755 $as_echo "no" >&6; }
22756 fi
22757 
22758 
22759   test -n "$DSYMUTIL" && break
22760 done
22761 
22762   else
22763     # The variable is set, but is it from the command line or the environment?
22764 
22765     # Try to remove the string !DSYMUTIL! from our list.
22766     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DSYMUTIL!/}
22767     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
22768       # If it failed, the variable was not from the command line. Ignore it,
22769       # but warn the user (except for BASH, which is always set by the calling BASH).
22770       if test "xDSYMUTIL" != xBASH; then
22771         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DSYMUTIL from the environment. Use command line variables instead." >&5
22772 $as_echo "$as_me: WARNING: Ignoring value of DSYMUTIL from the environment. Use command line variables instead." >&2;}
22773       fi
22774       # Try to locate tool using the code snippet
22775       for ac_prog in dsymutil
22776 do
22777   # Extract the first word of "$ac_prog", so it can be a program name with args.
22778 set dummy $ac_prog; ac_word=$2
22779 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22780 $as_echo_n "checking for $ac_word... " >&6; }
22781 if ${ac_cv_path_DSYMUTIL+:} false; then :
22782   $as_echo_n "(cached) " >&6
22783 else
22784   case $DSYMUTIL in
22785   [\\/]* | ?:[\\/]*)
22786   ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
22787   ;;
22788   *)
22789   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22790 for as_dir in $PATH
22791 do
22792   IFS=$as_save_IFS
22793   test -z "$as_dir" && as_dir=.
22794     for ac_exec_ext in '' $ac_executable_extensions; do
22795   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22796     ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
22797     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22798     break 2
22799   fi
22800 done
22801   done
22802 IFS=$as_save_IFS
22803 
22804   ;;
22805 esac
22806 fi
22807 DSYMUTIL=$ac_cv_path_DSYMUTIL
22808 if test -n "$DSYMUTIL"; then
22809   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
22810 $as_echo "$DSYMUTIL" >&6; }
22811 else
22812   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22813 $as_echo "no" >&6; }
22814 fi
22815 
22816 
22817   test -n "$DSYMUTIL" && break
22818 done
22819 
22820     else
22821       # If it succeeded, then it was overridden by the user. We will use it
22822       # for the tool.
22823 
22824       # First remove it from the list of overridden variables, so we can test
22825       # for unknown variables in the end.
22826       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
22827 
22828       # Check if we try to supply an empty value
22829       if test "x$DSYMUTIL" = x; then
22830         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool DSYMUTIL= (no value)" >&5
22831 $as_echo "$as_me: Setting user supplied tool DSYMUTIL= (no value)" >&6;}
22832         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DSYMUTIL" >&5
22833 $as_echo_n "checking for DSYMUTIL... " >&6; }
22834         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
22835 $as_echo "disabled" >&6; }
22836       else
22837         # Check if the provided tool contains a complete path.
22838         tool_specified="$DSYMUTIL"
22839         tool_basename="${tool_specified##*/}"
22840         if test "x$tool_basename" = "x$tool_specified"; then
22841           # A command without a complete path is provided, search $PATH.
22842           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DSYMUTIL=$tool_basename" >&5
22843 $as_echo "$as_me: Will search for user supplied tool DSYMUTIL=$tool_basename" >&6;}
22844           # Extract the first word of "$tool_basename", so it can be a program name with args.
22845 set dummy $tool_basename; ac_word=$2
22846 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22847 $as_echo_n "checking for $ac_word... " >&6; }
22848 if ${ac_cv_path_DSYMUTIL+:} false; then :
22849   $as_echo_n "(cached) " >&6
22850 else
22851   case $DSYMUTIL in
22852   [\\/]* | ?:[\\/]*)
22853   ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
22854   ;;
22855   *)
22856   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22857 for as_dir in $PATH
22858 do
22859   IFS=$as_save_IFS
22860   test -z "$as_dir" && as_dir=.
22861     for ac_exec_ext in '' $ac_executable_extensions; do
22862   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22863     ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
22864     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22865     break 2
22866   fi
22867 done
22868   done
22869 IFS=$as_save_IFS
22870 
22871   ;;
22872 esac
22873 fi
22874 DSYMUTIL=$ac_cv_path_DSYMUTIL
22875 if test -n "$DSYMUTIL"; then
22876   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
22877 $as_echo "$DSYMUTIL" >&6; }
22878 else
22879   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22880 $as_echo "no" >&6; }
22881 fi
22882 
22883 
22884           if test "x$DSYMUTIL" = x; then
22885             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
22886           fi
22887         else
22888           # Otherwise we believe it is a complete path. Use it as it is.
22889           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DSYMUTIL=$tool_specified" >&5
22890 $as_echo "$as_me: Will use user supplied tool DSYMUTIL=$tool_specified" >&6;}
22891           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DSYMUTIL" >&5
22892 $as_echo_n "checking for DSYMUTIL... " >&6; }
22893           if test ! -x "$tool_specified"; then
22894             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
22895 $as_echo "not found" >&6; }
22896             as_fn_error $? "User supplied tool DSYMUTIL=$tool_specified does not exist or is not executable" "$LINENO" 5
22897           fi
22898           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
22899 $as_echo "$tool_specified" >&6; }
22900         fi
22901       fi
22902     fi
22903 
22904   fi
22905 
22906 
22907 
22908   if test "x$DSYMUTIL" = x; then
22909     as_fn_error $? "Could not find required tool for DSYMUTIL" "$LINENO" 5
22910   fi
22911 
22912 
22913 
22914 
22915 
22916   # Publish this variable in the help.
22917 
22918 
22919   if [ -z "${XATTR+x}" ]; then
22920     # The variable is not set by user, try to locate tool using the code snippet
22921     for ac_prog in xattr
22922 do
22923   # Extract the first word of "$ac_prog", so it can be a program name with args.
22924 set dummy $ac_prog; ac_word=$2
22925 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22926 $as_echo_n "checking for $ac_word... " >&6; }
22927 if ${ac_cv_path_XATTR+:} false; then :
22928   $as_echo_n "(cached) " >&6
22929 else
22930   case $XATTR in
22931   [\\/]* | ?:[\\/]*)
22932   ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
22933   ;;
22934   *)
22935   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22936 for as_dir in $PATH
22937 do
22938   IFS=$as_save_IFS
22939   test -z "$as_dir" && as_dir=.
22940     for ac_exec_ext in '' $ac_executable_extensions; do
22941   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22942     ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
22943     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22944     break 2
22945   fi
22946 done
22947   done
22948 IFS=$as_save_IFS
22949 
22950   ;;
22951 esac
22952 fi
22953 XATTR=$ac_cv_path_XATTR
22954 if test -n "$XATTR"; then
22955   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
22956 $as_echo "$XATTR" >&6; }
22957 else
22958   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22959 $as_echo "no" >&6; }
22960 fi
22961 
22962 
22963   test -n "$XATTR" && break
22964 done
22965 
22966   else
22967     # The variable is set, but is it from the command line or the environment?
22968 
22969     # Try to remove the string !XATTR! from our list.
22970     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!XATTR!/}
22971     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
22972       # If it failed, the variable was not from the command line. Ignore it,
22973       # but warn the user (except for BASH, which is always set by the calling BASH).
22974       if test "xXATTR" != xBASH; then
22975         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of XATTR from the environment. Use command line variables instead." >&5
22976 $as_echo "$as_me: WARNING: Ignoring value of XATTR from the environment. Use command line variables instead." >&2;}
22977       fi
22978       # Try to locate tool using the code snippet
22979       for ac_prog in xattr
22980 do
22981   # Extract the first word of "$ac_prog", so it can be a program name with args.
22982 set dummy $ac_prog; ac_word=$2
22983 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22984 $as_echo_n "checking for $ac_word... " >&6; }
22985 if ${ac_cv_path_XATTR+:} false; then :
22986   $as_echo_n "(cached) " >&6
22987 else
22988   case $XATTR in
22989   [\\/]* | ?:[\\/]*)
22990   ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
22991   ;;
22992   *)
22993   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22994 for as_dir in $PATH
22995 do
22996   IFS=$as_save_IFS
22997   test -z "$as_dir" && as_dir=.
22998     for ac_exec_ext in '' $ac_executable_extensions; do
22999   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23000     ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
23001     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23002     break 2
23003   fi
23004 done
23005   done
23006 IFS=$as_save_IFS
23007 
23008   ;;
23009 esac
23010 fi
23011 XATTR=$ac_cv_path_XATTR
23012 if test -n "$XATTR"; then
23013   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
23014 $as_echo "$XATTR" >&6; }
23015 else
23016   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23017 $as_echo "no" >&6; }
23018 fi
23019 
23020 
23021   test -n "$XATTR" && break
23022 done
23023 
23024     else
23025       # If it succeeded, then it was overridden by the user. We will use it
23026       # for the tool.
23027 
23028       # First remove it from the list of overridden variables, so we can test
23029       # for unknown variables in the end.
23030       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
23031 
23032       # Check if we try to supply an empty value
23033       if test "x$XATTR" = x; then
23034         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool XATTR= (no value)" >&5
23035 $as_echo "$as_me: Setting user supplied tool XATTR= (no value)" >&6;}
23036         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XATTR" >&5
23037 $as_echo_n "checking for XATTR... " >&6; }
23038         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
23039 $as_echo "disabled" >&6; }
23040       else
23041         # Check if the provided tool contains a complete path.
23042         tool_specified="$XATTR"
23043         tool_basename="${tool_specified##*/}"
23044         if test "x$tool_basename" = "x$tool_specified"; then
23045           # A command without a complete path is provided, search $PATH.
23046           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool XATTR=$tool_basename" >&5
23047 $as_echo "$as_me: Will search for user supplied tool XATTR=$tool_basename" >&6;}
23048           # Extract the first word of "$tool_basename", so it can be a program name with args.
23049 set dummy $tool_basename; ac_word=$2
23050 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23051 $as_echo_n "checking for $ac_word... " >&6; }
23052 if ${ac_cv_path_XATTR+:} false; then :
23053   $as_echo_n "(cached) " >&6
23054 else
23055   case $XATTR in
23056   [\\/]* | ?:[\\/]*)
23057   ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
23058   ;;
23059   *)
23060   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23061 for as_dir in $PATH
23062 do
23063   IFS=$as_save_IFS
23064   test -z "$as_dir" && as_dir=.
23065     for ac_exec_ext in '' $ac_executable_extensions; do
23066   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23067     ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
23068     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23069     break 2
23070   fi
23071 done
23072   done
23073 IFS=$as_save_IFS
23074 
23075   ;;
23076 esac
23077 fi
23078 XATTR=$ac_cv_path_XATTR
23079 if test -n "$XATTR"; then
23080   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
23081 $as_echo "$XATTR" >&6; }
23082 else
23083   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23084 $as_echo "no" >&6; }
23085 fi
23086 
23087 
23088           if test "x$XATTR" = x; then
23089             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
23090           fi
23091         else
23092           # Otherwise we believe it is a complete path. Use it as it is.
23093           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool XATTR=$tool_specified" >&5
23094 $as_echo "$as_me: Will use user supplied tool XATTR=$tool_specified" >&6;}
23095           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XATTR" >&5
23096 $as_echo_n "checking for XATTR... " >&6; }
23097           if test ! -x "$tool_specified"; then
23098             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
23099 $as_echo "not found" >&6; }
23100             as_fn_error $? "User supplied tool XATTR=$tool_specified does not exist or is not executable" "$LINENO" 5
23101           fi
23102           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
23103 $as_echo "$tool_specified" >&6; }
23104         fi
23105       fi
23106     fi
23107 
23108   fi
23109 
23110 
23111 
23112   if test "x$XATTR" = x; then
23113     as_fn_error $? "Could not find required tool for XATTR" "$LINENO" 5
23114   fi
23115 
23116 
23117 
23118 
23119   # Publish this variable in the help.
23120 
23121 
23122   if [ -z "${CODESIGN+x}" ]; then
23123     # The variable is not set by user, try to locate tool using the code snippet
23124     for ac_prog in codesign
23125 do
23126   # Extract the first word of "$ac_prog", so it can be a program name with args.
23127 set dummy $ac_prog; ac_word=$2
23128 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23129 $as_echo_n "checking for $ac_word... " >&6; }
23130 if ${ac_cv_path_CODESIGN+:} false; then :
23131   $as_echo_n "(cached) " >&6
23132 else
23133   case $CODESIGN in
23134   [\\/]* | ?:[\\/]*)
23135   ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
23136   ;;
23137   *)
23138   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23139 for as_dir in $PATH
23140 do
23141   IFS=$as_save_IFS
23142   test -z "$as_dir" && as_dir=.
23143     for ac_exec_ext in '' $ac_executable_extensions; do
23144   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23145     ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
23146     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23147     break 2
23148   fi
23149 done
23150   done
23151 IFS=$as_save_IFS
23152 
23153   ;;
23154 esac
23155 fi
23156 CODESIGN=$ac_cv_path_CODESIGN
23157 if test -n "$CODESIGN"; then
23158   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
23159 $as_echo "$CODESIGN" >&6; }
23160 else
23161   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23162 $as_echo "no" >&6; }
23163 fi
23164 
23165 
23166   test -n "$CODESIGN" && break
23167 done
23168 
23169   else
23170     # The variable is set, but is it from the command line or the environment?
23171 
23172     # Try to remove the string !CODESIGN! from our list.
23173     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CODESIGN!/}
23174     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
23175       # If it failed, the variable was not from the command line. Ignore it,
23176       # but warn the user (except for BASH, which is always set by the calling BASH).
23177       if test "xCODESIGN" != xBASH; then
23178         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CODESIGN from the environment. Use command line variables instead." >&5
23179 $as_echo "$as_me: WARNING: Ignoring value of CODESIGN from the environment. Use command line variables instead." >&2;}
23180       fi
23181       # Try to locate tool using the code snippet
23182       for ac_prog in codesign
23183 do
23184   # Extract the first word of "$ac_prog", so it can be a program name with args.
23185 set dummy $ac_prog; ac_word=$2
23186 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23187 $as_echo_n "checking for $ac_word... " >&6; }
23188 if ${ac_cv_path_CODESIGN+:} false; then :
23189   $as_echo_n "(cached) " >&6
23190 else
23191   case $CODESIGN in
23192   [\\/]* | ?:[\\/]*)
23193   ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
23194   ;;
23195   *)
23196   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23197 for as_dir in $PATH
23198 do
23199   IFS=$as_save_IFS
23200   test -z "$as_dir" && as_dir=.
23201     for ac_exec_ext in '' $ac_executable_extensions; do
23202   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23203     ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
23204     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23205     break 2
23206   fi
23207 done
23208   done
23209 IFS=$as_save_IFS
23210 
23211   ;;
23212 esac
23213 fi
23214 CODESIGN=$ac_cv_path_CODESIGN
23215 if test -n "$CODESIGN"; then
23216   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
23217 $as_echo "$CODESIGN" >&6; }
23218 else
23219   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23220 $as_echo "no" >&6; }
23221 fi
23222 
23223 
23224   test -n "$CODESIGN" && break
23225 done
23226 
23227     else
23228       # If it succeeded, then it was overridden by the user. We will use it
23229       # for the tool.
23230 
23231       # First remove it from the list of overridden variables, so we can test
23232       # for unknown variables in the end.
23233       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
23234 
23235       # Check if we try to supply an empty value
23236       if test "x$CODESIGN" = x; then
23237         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CODESIGN= (no value)" >&5
23238 $as_echo "$as_me: Setting user supplied tool CODESIGN= (no value)" >&6;}
23239         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CODESIGN" >&5
23240 $as_echo_n "checking for CODESIGN... " >&6; }
23241         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
23242 $as_echo "disabled" >&6; }
23243       else
23244         # Check if the provided tool contains a complete path.
23245         tool_specified="$CODESIGN"
23246         tool_basename="${tool_specified##*/}"
23247         if test "x$tool_basename" = "x$tool_specified"; then
23248           # A command without a complete path is provided, search $PATH.
23249           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CODESIGN=$tool_basename" >&5
23250 $as_echo "$as_me: Will search for user supplied tool CODESIGN=$tool_basename" >&6;}
23251           # Extract the first word of "$tool_basename", so it can be a program name with args.
23252 set dummy $tool_basename; ac_word=$2
23253 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23254 $as_echo_n "checking for $ac_word... " >&6; }
23255 if ${ac_cv_path_CODESIGN+:} false; then :
23256   $as_echo_n "(cached) " >&6
23257 else
23258   case $CODESIGN in
23259   [\\/]* | ?:[\\/]*)
23260   ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
23261   ;;
23262   *)
23263   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23264 for as_dir in $PATH
23265 do
23266   IFS=$as_save_IFS
23267   test -z "$as_dir" && as_dir=.
23268     for ac_exec_ext in '' $ac_executable_extensions; do
23269   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23270     ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
23271     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23272     break 2
23273   fi
23274 done
23275   done
23276 IFS=$as_save_IFS
23277 
23278   ;;
23279 esac
23280 fi
23281 CODESIGN=$ac_cv_path_CODESIGN
23282 if test -n "$CODESIGN"; then
23283   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
23284 $as_echo "$CODESIGN" >&6; }
23285 else
23286   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23287 $as_echo "no" >&6; }
23288 fi
23289 
23290 
23291           if test "x$CODESIGN" = x; then
23292             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
23293           fi
23294         else
23295           # Otherwise we believe it is a complete path. Use it as it is.
23296           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CODESIGN=$tool_specified" >&5
23297 $as_echo "$as_me: Will use user supplied tool CODESIGN=$tool_specified" >&6;}
23298           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CODESIGN" >&5
23299 $as_echo_n "checking for CODESIGN... " >&6; }
23300           if test ! -x "$tool_specified"; then
23301             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
23302 $as_echo "not found" >&6; }
23303             as_fn_error $? "User supplied tool CODESIGN=$tool_specified does not exist or is not executable" "$LINENO" 5
23304           fi
23305           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
23306 $as_echo "$tool_specified" >&6; }
23307         fi
23308       fi
23309     fi
23310 
23311   fi
23312 
23313 
23314     if test "x$CODESIGN" != "x"; then
23315       # Verify that the openjdk_codesign certificate is present
23316       { $as_echo "$as_me:${as_lineno-$LINENO}: checking if openjdk_codesign certificate is present" >&5
23317 $as_echo_n "checking if openjdk_codesign certificate is present... " >&6; }
23318       rm -f codesign-testfile
23319       touch codesign-testfile
23320       codesign -s openjdk_codesign codesign-testfile 2>&5 >&5 || CODESIGN=
23321       rm -f codesign-testfile
23322       if test "x$CODESIGN" = x; then
23323         { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23324 $as_echo "no" >&6; }
23325       else
23326         { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
23327 $as_echo "yes" >&6; }
23328       fi
23329     fi
23330 
23331 
23332 
23333   # Publish this variable in the help.
23334 
23335 
23336   if [ -z "${SETFILE+x}" ]; then
23337     # The variable is not set by user, try to locate tool using the code snippet
23338     for ac_prog in SetFile
23339 do
23340   # Extract the first word of "$ac_prog", so it can be a program name with args.
23341 set dummy $ac_prog; ac_word=$2
23342 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23343 $as_echo_n "checking for $ac_word... " >&6; }
23344 if ${ac_cv_path_SETFILE+:} false; then :
23345   $as_echo_n "(cached) " >&6
23346 else
23347   case $SETFILE in
23348   [\\/]* | ?:[\\/]*)
23349   ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
23350   ;;
23351   *)
23352   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23353 for as_dir in $PATH
23354 do
23355   IFS=$as_save_IFS
23356   test -z "$as_dir" && as_dir=.
23357     for ac_exec_ext in '' $ac_executable_extensions; do
23358   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23359     ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
23360     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23361     break 2
23362   fi
23363 done
23364   done
23365 IFS=$as_save_IFS
23366 
23367   ;;
23368 esac
23369 fi
23370 SETFILE=$ac_cv_path_SETFILE
23371 if test -n "$SETFILE"; then
23372   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
23373 $as_echo "$SETFILE" >&6; }
23374 else
23375   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23376 $as_echo "no" >&6; }
23377 fi
23378 
23379 
23380   test -n "$SETFILE" && break
23381 done
23382 
23383   else
23384     # The variable is set, but is it from the command line or the environment?
23385 
23386     # Try to remove the string !SETFILE! from our list.
23387     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SETFILE!/}
23388     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
23389       # If it failed, the variable was not from the command line. Ignore it,
23390       # but warn the user (except for BASH, which is always set by the calling BASH).
23391       if test "xSETFILE" != xBASH; then
23392         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SETFILE from the environment. Use command line variables instead." >&5
23393 $as_echo "$as_me: WARNING: Ignoring value of SETFILE from the environment. Use command line variables instead." >&2;}
23394       fi
23395       # Try to locate tool using the code snippet
23396       for ac_prog in SetFile
23397 do
23398   # Extract the first word of "$ac_prog", so it can be a program name with args.
23399 set dummy $ac_prog; ac_word=$2
23400 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23401 $as_echo_n "checking for $ac_word... " >&6; }
23402 if ${ac_cv_path_SETFILE+:} false; then :
23403   $as_echo_n "(cached) " >&6
23404 else
23405   case $SETFILE in
23406   [\\/]* | ?:[\\/]*)
23407   ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
23408   ;;
23409   *)
23410   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23411 for as_dir in $PATH
23412 do
23413   IFS=$as_save_IFS
23414   test -z "$as_dir" && as_dir=.
23415     for ac_exec_ext in '' $ac_executable_extensions; do
23416   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23417     ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
23418     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23419     break 2
23420   fi
23421 done
23422   done
23423 IFS=$as_save_IFS
23424 
23425   ;;
23426 esac
23427 fi
23428 SETFILE=$ac_cv_path_SETFILE
23429 if test -n "$SETFILE"; then
23430   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
23431 $as_echo "$SETFILE" >&6; }
23432 else
23433   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23434 $as_echo "no" >&6; }
23435 fi
23436 
23437 
23438   test -n "$SETFILE" && break
23439 done
23440 
23441     else
23442       # If it succeeded, then it was overridden by the user. We will use it
23443       # for the tool.
23444 
23445       # First remove it from the list of overridden variables, so we can test
23446       # for unknown variables in the end.
23447       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
23448 
23449       # Check if we try to supply an empty value
23450       if test "x$SETFILE" = x; then
23451         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool SETFILE= (no value)" >&5
23452 $as_echo "$as_me: Setting user supplied tool SETFILE= (no value)" >&6;}
23453         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SETFILE" >&5
23454 $as_echo_n "checking for SETFILE... " >&6; }
23455         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
23456 $as_echo "disabled" >&6; }
23457       else
23458         # Check if the provided tool contains a complete path.
23459         tool_specified="$SETFILE"
23460         tool_basename="${tool_specified##*/}"
23461         if test "x$tool_basename" = "x$tool_specified"; then
23462           # A command without a complete path is provided, search $PATH.
23463           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SETFILE=$tool_basename" >&5
23464 $as_echo "$as_me: Will search for user supplied tool SETFILE=$tool_basename" >&6;}
23465           # Extract the first word of "$tool_basename", so it can be a program name with args.
23466 set dummy $tool_basename; ac_word=$2
23467 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23468 $as_echo_n "checking for $ac_word... " >&6; }
23469 if ${ac_cv_path_SETFILE+:} false; then :
23470   $as_echo_n "(cached) " >&6
23471 else
23472   case $SETFILE in
23473   [\\/]* | ?:[\\/]*)
23474   ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
23475   ;;
23476   *)
23477   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23478 for as_dir in $PATH
23479 do
23480   IFS=$as_save_IFS
23481   test -z "$as_dir" && as_dir=.
23482     for ac_exec_ext in '' $ac_executable_extensions; do
23483   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23484     ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
23485     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23486     break 2
23487   fi
23488 done
23489   done
23490 IFS=$as_save_IFS
23491 
23492   ;;
23493 esac
23494 fi
23495 SETFILE=$ac_cv_path_SETFILE
23496 if test -n "$SETFILE"; then
23497   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
23498 $as_echo "$SETFILE" >&6; }
23499 else
23500   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23501 $as_echo "no" >&6; }
23502 fi
23503 
23504 
23505           if test "x$SETFILE" = x; then
23506             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
23507           fi
23508         else
23509           # Otherwise we believe it is a complete path. Use it as it is.
23510           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SETFILE=$tool_specified" >&5
23511 $as_echo "$as_me: Will use user supplied tool SETFILE=$tool_specified" >&6;}
23512           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SETFILE" >&5
23513 $as_echo_n "checking for SETFILE... " >&6; }
23514           if test ! -x "$tool_specified"; then
23515             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
23516 $as_echo "not found" >&6; }
23517             as_fn_error $? "User supplied tool SETFILE=$tool_specified does not exist or is not executable" "$LINENO" 5
23518           fi
23519           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
23520 $as_echo "$tool_specified" >&6; }
23521         fi
23522       fi
23523     fi
23524 
23525   fi
23526 
23527 
23528 
23529   if test "x$SETFILE" = x; then
23530     as_fn_error $? "Could not find required tool for SETFILE" "$LINENO" 5
23531   fi
23532 
23533 
23534   fi
23535 
23536 
23537   # Test if bash supports pipefail.
23538   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if bash supports pipefail" >&5
23539 $as_echo_n "checking if bash supports pipefail... " >&6; }
23540   if ${BASH} -c 'set -o pipefail'; then
23541     BASH_ARGS="$BASH_ARGS -o pipefail"
23542     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
23543 $as_echo "yes" >&6; }
23544   else
23545     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23546 $as_echo "no" >&6; }
23547   fi
23548 
23549   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if bash supports errexit (-e)" >&5
23550 $as_echo_n "checking if bash supports errexit (-e)... " >&6; }
23551   if ${BASH} -e -c 'true'; then
23552     BASH_ARGS="$BASH_ARGS -e"
23553     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
23554 $as_echo "yes" >&6; }
23555   else
23556     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23557 $as_echo "no" >&6; }
23558   fi
23559 
23560 
23561 
23562 
23563 # Check if pkg-config is available.
23564 
23565 
23566 if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then
23567         if test -n "$ac_tool_prefix"; then
23568   # Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args.
23569 set dummy ${ac_tool_prefix}pkg-config; ac_word=$2
23570 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23571 $as_echo_n "checking for $ac_word... " >&6; }
23572 if ${ac_cv_path_PKG_CONFIG+:} false; then :
23573   $as_echo_n "(cached) " >&6
23574 else
23575   case $PKG_CONFIG in
23576   [\\/]* | ?:[\\/]*)
23577   ac_cv_path_PKG_CONFIG="$PKG_CONFIG" # Let the user override the test with a path.
23578   ;;
23579   *)
23580   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23581 for as_dir in $PATH
23582 do
23583   IFS=$as_save_IFS
23584   test -z "$as_dir" && as_dir=.
23585     for ac_exec_ext in '' $ac_executable_extensions; do
23586   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23587     ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
23588     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23589     break 2
23590   fi
23591 done
23592   done
23593 IFS=$as_save_IFS
23594 
23595   ;;
23596 esac
23597 fi
23598 PKG_CONFIG=$ac_cv_path_PKG_CONFIG
23599 if test -n "$PKG_CONFIG"; then
23600   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
23601 $as_echo "$PKG_CONFIG" >&6; }
23602 else
23603   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23604 $as_echo "no" >&6; }
23605 fi
23606 
23607 
23608 fi
23609 if test -z "$ac_cv_path_PKG_CONFIG"; then
23610   ac_pt_PKG_CONFIG=$PKG_CONFIG
23611   # Extract the first word of "pkg-config", so it can be a program name with args.
23612 set dummy pkg-config; ac_word=$2
23613 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23614 $as_echo_n "checking for $ac_word... " >&6; }
23615 if ${ac_cv_path_ac_pt_PKG_CONFIG+:} false; then :
23616   $as_echo_n "(cached) " >&6
23617 else
23618   case $ac_pt_PKG_CONFIG in
23619   [\\/]* | ?:[\\/]*)
23620   ac_cv_path_ac_pt_PKG_CONFIG="$ac_pt_PKG_CONFIG" # Let the user override the test with a path.
23621   ;;
23622   *)
23623   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23624 for as_dir in $PATH
23625 do
23626   IFS=$as_save_IFS
23627   test -z "$as_dir" && as_dir=.
23628     for ac_exec_ext in '' $ac_executable_extensions; do
23629   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23630     ac_cv_path_ac_pt_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
23631     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23632     break 2
23633   fi
23634 done
23635   done
23636 IFS=$as_save_IFS
23637 
23638   ;;
23639 esac
23640 fi
23641 ac_pt_PKG_CONFIG=$ac_cv_path_ac_pt_PKG_CONFIG
23642 if test -n "$ac_pt_PKG_CONFIG"; then
23643   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_pt_PKG_CONFIG" >&5
23644 $as_echo "$ac_pt_PKG_CONFIG" >&6; }
23645 else
23646   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23647 $as_echo "no" >&6; }
23648 fi
23649 
23650   if test "x$ac_pt_PKG_CONFIG" = x; then
23651     PKG_CONFIG=""
23652   else
23653     case $cross_compiling:$ac_tool_warned in
23654 yes:)
23655 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
23656 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
23657 ac_tool_warned=yes ;;
23658 esac
23659     PKG_CONFIG=$ac_pt_PKG_CONFIG
23660   fi
23661 else
23662   PKG_CONFIG="$ac_cv_path_PKG_CONFIG"
23663 fi
23664 
23665 fi
23666 if test -n "$PKG_CONFIG"; then
23667         _pkg_min_version=0.9.0
23668         { $as_echo "$as_me:${as_lineno-$LINENO}: checking pkg-config is at least version $_pkg_min_version" >&5
23669 $as_echo_n "checking pkg-config is at least version $_pkg_min_version... " >&6; }
23670         if $PKG_CONFIG --atleast-pkgconfig-version $_pkg_min_version; then
23671                 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
23672 $as_echo "yes" >&6; }
23673         else
23674                 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23675 $as_echo "no" >&6; }
23676                 PKG_CONFIG=""
23677         fi
23678 
23679 fi
23680 
23681 # After basic tools have been setup, we can check build os specific details.
23682 
23683   ###############################################################################
23684 
23685   # Note that this is the build platform OS version!
23686 
23687   OS_VERSION="`uname -r | ${SED} 's!\.! !g' | ${SED} 's!-! !g'`"
23688   OS_VERSION_MAJOR="`${ECHO} ${OS_VERSION} | ${CUT} -f 1 -d ' '`"
23689   OS_VERSION_MINOR="`${ECHO} ${OS_VERSION} | ${CUT} -f 2 -d ' '`"
23690   OS_VERSION_MICRO="`${ECHO} ${OS_VERSION} | ${CUT} -f 3 -d ' '`"
23691 
23692 
23693 
23694 
23695 
23696 # Misc basic settings
23697 
23698 
23699 # Check whether --with-default-make-target was given.
23700 if test "${with_default_make_target+set}" = set; then :
23701   withval=$with_default_make_target;
23702 fi
23703 
23704   if test "x$with_default_make_target" = "x" \
23705       || test "x$with_default_make_target" = "xyes"; then
23706     DEFAULT_MAKE_TARGET="exploded-image"
23707   elif test "x$with_default_make_target" = "xno"; then
23708     as_fn_error $? "--without-default-make-target is not a valid option" "$LINENO" 5
23709   else
23710     DEFAULT_MAKE_TARGET="$with_default_make_target"
23711   fi
23712 
23713 
23714 
23715 
23716 ###############################################################################
23717 #
23718 # Determine OpenJDK variants, options and version numbers.
23719 #
23720 ###############################################################################
23721 
23722 # We need build & target for this.
23723 
23724   # Should we build a JDK/JVM with headful support (ie a graphical ui)?
23725   # We always build headless support.
23726   { $as_echo "$as_me:${as_lineno-$LINENO}: checking headful support" >&5
23727 $as_echo_n "checking headful support... " >&6; }
23728   # Check whether --enable-headful was given.
23729 if test "${enable_headful+set}" = set; then :
23730   enableval=$enable_headful; SUPPORT_HEADFUL=${enable_headful}
23731 else
23732   SUPPORT_HEADFUL=yes
23733 fi
23734 
23735 
23736   SUPPORT_HEADLESS=yes
23737   BUILD_HEADLESS="BUILD_HEADLESS:=true"
23738 
23739   if test "x$SUPPORT_HEADFUL" = xyes; then
23740     # We are building both headful and headless.
23741     headful_msg="include support for both headful and headless"
23742   fi
23743 
23744   if test "x$SUPPORT_HEADFUL" = xno; then
23745     # Thus we are building headless only.
23746     BUILD_HEADLESS="BUILD_HEADLESS:=true"
23747     headful_msg="headless only"
23748   fi
23749 
23750   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $headful_msg" >&5
23751 $as_echo "$headful_msg" >&6; }
23752 
23753 
23754 
23755 
23756 
23757   # Choose cacerts source file
23758 
23759 # Check whether --with-cacerts-file was given.
23760 if test "${with_cacerts_file+set}" = set; then :
23761   withval=$with_cacerts_file;
23762 fi
23763 
23764   if test "x$with_cacerts_file" != x; then
23765     CACERTS_FILE=$with_cacerts_file
23766   fi
23767 
23768 
23769   # Enable or disable unlimited crypto
23770   # Check whether --enable-unlimited-crypto was given.
23771 if test "${enable_unlimited_crypto+set}" = set; then :
23772   enableval=$enable_unlimited_crypto;
23773 else
23774   enable_unlimited_crypto=no
23775 fi
23776 
23777   if test "x$enable_unlimited_crypto" = "xyes"; then
23778     UNLIMITED_CRYPTO=true
23779   else
23780     UNLIMITED_CRYPTO=false
23781   fi
23782 
23783 
23784   # Should we build the serviceability agent (SA)?
23785   INCLUDE_SA=true
23786   if   [[ " $JVM_VARIANTS " =~ " zero " ]]   ||   [[ " $JVM_VARIANTS " =~ " zeroshark " ]]  ; then
23787     INCLUDE_SA=false
23788   fi
23789   if test "x$OPENJDK_TARGET_OS" = xaix ; then
23790     INCLUDE_SA=false
23791   fi
23792   if test "x$OPENJDK_TARGET_CPU" = xaarch64; then
23793     INCLUDE_SA=false
23794   fi
23795 
23796 
23797   # Compress jars
23798   COMPRESS_JARS=false
23799 
23800 
23801 
23802   # Setup default copyright year. Mostly overridden when building close to a new year.
23803 
23804 # Check whether --with-copyright-year was given.
23805 if test "${with_copyright_year+set}" = set; then :
23806   withval=$with_copyright_year;
23807 fi
23808 
23809   if test "x$with_copyright_year" = xyes; then
23810     as_fn_error $? "Copyright year must have a value" "$LINENO" 5
23811   elif test "x$with_copyright_year" != x; then
23812     COPYRIGHT_YEAR="$with_copyright_year"
23813   else
23814     COPYRIGHT_YEAR=`date +'%Y'`
23815   fi
23816 
23817 
23818 
23819   # Check whether --enable-keep-packaged-modules was given.
23820 if test "${enable_keep_packaged_modules+set}" = set; then :
23821   enableval=$enable_keep_packaged_modules;
23822 fi
23823 
23824 
23825   if test "x$enable_keep_packaged_modules" = "xyes"; then
23826     { $as_echo "$as_me:${as_lineno-$LINENO}: checking if packaged modules are kept" >&5
23827 $as_echo_n "checking if packaged modules are kept... " >&6; }
23828     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
23829 $as_echo "yes" >&6; }
23830     JLINK_KEEP_PACKAGED_MODULES=true
23831   elif test "x$enable_keep_packaged_modules" = "xno"; then
23832     { $as_echo "$as_me:${as_lineno-$LINENO}: checking if packaged modules are kept" >&5
23833 $as_echo_n "checking if packaged modules are kept... " >&6; }
23834     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23835 $as_echo "no" >&6; }
23836     JLINK_KEEP_PACKAGED_MODULES=false
23837   elif test "x$enable_keep_packaged_modules" = "x"; then
23838     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes (default)" >&5
23839 $as_echo "yes (default)" >&6; }
23840     JLINK_KEEP_PACKAGED_MODULES=true
23841   else
23842     as_fn_error $? "--enable-keep-packaged-modules accepts no argument" "$LINENO" 5
23843   fi
23844 
23845 
23846 
23847 
23848   # Warn user that old version arguments are deprecated.
23849 
23850 
23851 # Check whether --with-milestone was given.
23852 if test "${with_milestone+set}" = set; then :
23853   withval=$with_milestone; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-milestone is deprecated and will be ignored." >&5
23854 $as_echo "$as_me: WARNING: Option --with-milestone is deprecated and will be ignored." >&2;}
23855 fi
23856 
23857 
23858 
23859 
23860 # Check whether --with-update-version was given.
23861 if test "${with_update_version+set}" = set; then :
23862   withval=$with_update_version; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-update-version is deprecated and will be ignored." >&5
23863 $as_echo "$as_me: WARNING: Option --with-update-version is deprecated and will be ignored." >&2;}
23864 fi
23865 
23866 
23867 
23868 
23869 # Check whether --with-user-release-suffix was given.
23870 if test "${with_user_release_suffix+set}" = set; then :
23871   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
23872 $as_echo "$as_me: WARNING: Option --with-user-release-suffix is deprecated and will be ignored." >&2;}
23873 fi
23874 
23875 
23876 
23877 
23878 # Check whether --with-build-number was given.
23879 if test "${with_build_number+set}" = set; then :
23880   withval=$with_build_number; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-build-number is deprecated and will be ignored." >&5
23881 $as_echo "$as_me: WARNING: Option --with-build-number is deprecated and will be ignored." >&2;}
23882 fi
23883 
23884 
23885 
23886   # Source the version numbers file
23887   . $AUTOCONF_DIR/version-numbers
23888 
23889   # Some non-version number information is set in that file
23890 
23891 
23892 
23893 
23894 
23895 
23896 
23897 
23898 
23899   # Override version from arguments
23900 
23901   # If --with-version-string is set, process it first. It is possible to
23902   # override parts with more specific flags, since these are processed later.
23903 
23904 # Check whether --with-version-string was given.
23905 if test "${with_version_string+set}" = set; then :
23906   withval=$with_version_string;
23907 fi
23908 
23909   if test "x$with_version_string" = xyes; then
23910     as_fn_error $? "--with-version-string must have a value" "$LINENO" 5
23911   elif test "x$with_version_string" != x; then
23912     # Additional [] needed to keep m4 from mangling shell constructs.
23913     if  [[ $with_version_string =~ ^([0-9]+)(\.([0-9]+))?(\.([0-9]+))?(\.([0-9]+))?(-([a-zA-Z]+))?((\+)([0-9]+)?(-([-a-zA-Z0-9.]+))?)?$ ]] ; then
23914       VERSION_MAJOR=${BASH_REMATCH[1]}
23915       VERSION_MINOR=${BASH_REMATCH[3]}
23916       VERSION_SECURITY=${BASH_REMATCH[5]}
23917       VERSION_PATCH=${BASH_REMATCH[7]}
23918       VERSION_PRE=${BASH_REMATCH[9]}
23919       version_plus_separator=${BASH_REMATCH[11]}
23920       VERSION_BUILD=${BASH_REMATCH[12]}
23921       VERSION_OPT=${BASH_REMATCH[14]}
23922       # Unspecified numerical fields are interpreted as 0.
23923       if test "x$VERSION_MINOR" = x; then
23924         VERSION_MINOR=0
23925       fi
23926       if test "x$VERSION_SECURITY" = x; then
23927         VERSION_SECURITY=0
23928       fi
23929       if test "x$VERSION_PATCH" = x; then
23930         VERSION_PATCH=0
23931       fi
23932       if test "x$version_plus_separator" != x \
23933           && test "x$VERSION_BUILD$VERSION_OPT" = x; then
23934         as_fn_error $? "Version string contains + but both 'BUILD' and 'OPT' are missing" "$LINENO" 5
23935       fi
23936       # Stop the version part process from setting default values.
23937       # We still allow them to explicitely override though.
23938       NO_DEFAULT_VERSION_PARTS=true
23939     else
23940       as_fn_error $? "--with-version-string fails to parse as a valid version string: $with_version_string" "$LINENO" 5
23941     fi
23942   fi
23943 
23944 
23945 # Check whether --with-version-pre was given.
23946 if test "${with_version_pre+set}" = set; then :
23947   withval=$with_version_pre; with_version_pre_present=true
23948 else
23949   with_version_pre_present=false
23950 fi
23951 
23952 
23953   if test "x$with_version_pre_present" = xtrue; then
23954     if test "x$with_version_pre" = xyes; then
23955       as_fn_error $? "--with-version-pre must have a value" "$LINENO" 5
23956     elif test "x$with_version_pre" = xno; then
23957       # Interpret --without-* as empty string instead of the literal "no"
23958       VERSION_PRE=
23959     else
23960       # Only [a-zA-Z] is allowed in the VERSION_PRE. Outer [ ] to quote m4.
23961        VERSION_PRE=`$ECHO "$with_version_pre" | $TR -c -d '[a-z][A-Z]'`
23962       if test "x$VERSION_PRE" != "x$with_version_pre"; then
23963         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: --with-version-pre value has been sanitized from '$with_version_pre' to '$VERSION_PRE'" >&5
23964 $as_echo "$as_me: WARNING: --with-version-pre value has been sanitized from '$with_version_pre' to '$VERSION_PRE'" >&2;}
23965       fi
23966     fi
23967   else
23968     if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
23969       # Default is to use "internal" as pre
23970       VERSION_PRE="internal"
23971     fi
23972   fi
23973 
23974 
23975 # Check whether --with-version-opt was given.
23976 if test "${with_version_opt+set}" = set; then :
23977   withval=$with_version_opt; with_version_opt_present=true
23978 else
23979   with_version_opt_present=false
23980 fi
23981 
23982 
23983   if test "x$with_version_opt_present" = xtrue; then
23984     if test "x$with_version_opt" = xyes; then
23985       as_fn_error $? "--with-version-opt must have a value" "$LINENO" 5
23986     elif test "x$with_version_opt" = xno; then
23987       # Interpret --without-* as empty string instead of the literal "no"
23988       VERSION_OPT=
23989     else
23990       # Only [-.a-zA-Z0-9] is allowed in the VERSION_OPT. Outer [ ] to quote m4.
23991        VERSION_OPT=`$ECHO "$with_version_opt" | $TR -c -d '[a-z][A-Z][0-9].-'`
23992       if test "x$VERSION_OPT" != "x$with_version_opt"; then
23993         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: --with-version-opt value has been sanitized from '$with_version_opt' to '$VERSION_OPT'" >&5
23994 $as_echo "$as_me: WARNING: --with-version-opt value has been sanitized from '$with_version_opt' to '$VERSION_OPT'" >&2;}
23995       fi
23996     fi
23997   else
23998     if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
23999       # Default is to calculate a string like this <timestamp>.<username>.<base dir name>
24000       timestamp=`$DATE '+%Y-%m-%d-%H%M%S'`
24001       # Outer [ ] to quote m4.
24002        basedirname=`$BASENAME "$TOPDIR" | $TR -d -c '[a-z][A-Z][0-9].-'`
24003       VERSION_OPT="$timestamp.$USERNAME.$basedirname"
24004     fi
24005   fi
24006 
24007 
24008 # Check whether --with-version-build was given.
24009 if test "${with_version_build+set}" = set; then :
24010   withval=$with_version_build; with_version_build_present=true
24011 else
24012   with_version_build_present=false
24013 fi
24014 
24015 
24016   if test "x$with_version_build_present" = xtrue; then
24017     if test "x$with_version_build" = xyes; then
24018       as_fn_error $? "--with-version-build must have a value" "$LINENO" 5
24019     elif test "x$with_version_build" = xno; then
24020       # Interpret --without-* as empty string instead of the literal "no"
24021       VERSION_BUILD=
24022     elif test "x$with_version_build" = x; then
24023       VERSION_BUILD=
24024     else
24025 
24026   # Additional [] needed to keep m4 from mangling shell constructs.
24027   if  ! [[ "$with_version_build" =~ ^0*([1-9][0-9]*)|(0)$ ]]  ; then
24028     as_fn_error $? "\"$with_version_build\" is not a valid numerical value for VERSION_BUILD" "$LINENO" 5
24029   fi
24030   # Extract the version number without leading zeros.
24031   cleaned_value=${BASH_REMATCH[1]}
24032   if test "x$cleaned_value" = x; then
24033     # Special case for zero
24034     cleaned_value=${BASH_REMATCH[2]}
24035   fi
24036 
24037   if test $cleaned_value -gt 255; then
24038     as_fn_error $? "VERSION_BUILD is given as $with_version_build. This is greater than 255 which is not allowed." "$LINENO" 5
24039   fi
24040   if test "x$cleaned_value" != "x$with_version_build"; then
24041     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Value for VERSION_BUILD has been sanitized from '$with_version_build' to '$cleaned_value'" >&5
24042 $as_echo "$as_me: WARNING: Value for VERSION_BUILD has been sanitized from '$with_version_build' to '$cleaned_value'" >&2;}
24043   fi
24044   VERSION_BUILD=$cleaned_value
24045 
24046     fi
24047   else
24048     if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
24049       # Default is to not have a build number.
24050       VERSION_BUILD=""
24051       # FIXME: Until all code can cope with an empty VERSION_BUILD, set it to 0.
24052       VERSION_BUILD=0
24053     fi
24054   fi
24055 
24056 
24057 # Check whether --with-version-major was given.
24058 if test "${with_version_major+set}" = set; then :
24059   withval=$with_version_major; with_version_major_present=true
24060 else
24061   with_version_major_present=false
24062 fi
24063 
24064 
24065   if test "x$with_version_major_present" = xtrue; then
24066     if test "x$with_version_major" = xyes; then
24067       as_fn_error $? "--with-version-major must have a value" "$LINENO" 5
24068     else
24069 
24070   # Additional [] needed to keep m4 from mangling shell constructs.
24071   if  ! [[ "$with_version_major" =~ ^0*([1-9][0-9]*)|(0)$ ]]  ; then
24072     as_fn_error $? "\"$with_version_major\" is not a valid numerical value for VERSION_MAJOR" "$LINENO" 5
24073   fi
24074   # Extract the version number without leading zeros.
24075   cleaned_value=${BASH_REMATCH[1]}
24076   if test "x$cleaned_value" = x; then
24077     # Special case for zero
24078     cleaned_value=${BASH_REMATCH[2]}
24079   fi
24080 
24081   if test $cleaned_value -gt 255; then
24082     as_fn_error $? "VERSION_MAJOR is given as $with_version_major. This is greater than 255 which is not allowed." "$LINENO" 5
24083   fi
24084   if test "x$cleaned_value" != "x$with_version_major"; then
24085     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Value for VERSION_MAJOR has been sanitized from '$with_version_major' to '$cleaned_value'" >&5
24086 $as_echo "$as_me: WARNING: Value for VERSION_MAJOR has been sanitized from '$with_version_major' to '$cleaned_value'" >&2;}
24087   fi
24088   VERSION_MAJOR=$cleaned_value
24089 
24090     fi
24091   else
24092     if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
24093       # Default is to get value from version-numbers
24094       VERSION_MAJOR="$DEFAULT_VERSION_MAJOR"
24095     fi
24096   fi
24097 
24098 
24099 # Check whether --with-version-minor was given.
24100 if test "${with_version_minor+set}" = set; then :
24101   withval=$with_version_minor; with_version_minor_present=true
24102 else
24103   with_version_minor_present=false
24104 fi
24105 
24106 
24107   if test "x$with_version_minor_present" = xtrue; then
24108     if test "x$with_version_minor" = xyes; then
24109       as_fn_error $? "--with-version-minor must have a value" "$LINENO" 5
24110     elif test "x$with_version_minor" = xno; then
24111       # Interpret --without-* as empty string (i.e. 0) instead of the literal "no"
24112       VERSION_MINOR=0
24113     elif test "x$with_version_minor" = x; then
24114       VERSION_MINOR=0
24115     else
24116 
24117   # Additional [] needed to keep m4 from mangling shell constructs.
24118   if  ! [[ "$with_version_minor" =~ ^0*([1-9][0-9]*)|(0)$ ]]  ; then
24119     as_fn_error $? "\"$with_version_minor\" is not a valid numerical value for VERSION_MINOR" "$LINENO" 5
24120   fi
24121   # Extract the version number without leading zeros.
24122   cleaned_value=${BASH_REMATCH[1]}
24123   if test "x$cleaned_value" = x; then
24124     # Special case for zero
24125     cleaned_value=${BASH_REMATCH[2]}
24126   fi
24127 
24128   if test $cleaned_value -gt 255; then
24129     as_fn_error $? "VERSION_MINOR is given as $with_version_minor. This is greater than 255 which is not allowed." "$LINENO" 5
24130   fi
24131   if test "x$cleaned_value" != "x$with_version_minor"; then
24132     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Value for VERSION_MINOR has been sanitized from '$with_version_minor' to '$cleaned_value'" >&5
24133 $as_echo "$as_me: WARNING: Value for VERSION_MINOR has been sanitized from '$with_version_minor' to '$cleaned_value'" >&2;}
24134   fi
24135   VERSION_MINOR=$cleaned_value
24136 
24137     fi
24138   else
24139     if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
24140       # Default is 0, if unspecified
24141       VERSION_MINOR=0
24142     fi
24143   fi
24144 
24145 
24146 # Check whether --with-version-security was given.
24147 if test "${with_version_security+set}" = set; then :
24148   withval=$with_version_security; with_version_security_present=true
24149 else
24150   with_version_security_present=false
24151 fi
24152 
24153 
24154   if test "x$with_version_security_present" = xtrue; then
24155     if test "x$with_version_security" = xyes; then
24156       as_fn_error $? "--with-version-security must have a value" "$LINENO" 5
24157     elif test "x$with_version_security" = xno; then
24158       # Interpret --without-* as empty string (i.e. 0) instead of the literal "no"
24159       VERSION_SECURITY=0
24160     elif test "x$with_version_security" = x; then
24161       VERSION_SECURITY=0
24162     else
24163 
24164   # Additional [] needed to keep m4 from mangling shell constructs.
24165   if  ! [[ "$with_version_security" =~ ^0*([1-9][0-9]*)|(0)$ ]]  ; then
24166     as_fn_error $? "\"$with_version_security\" is not a valid numerical value for VERSION_SECURITY" "$LINENO" 5
24167   fi
24168   # Extract the version number without leading zeros.
24169   cleaned_value=${BASH_REMATCH[1]}
24170   if test "x$cleaned_value" = x; then
24171     # Special case for zero
24172     cleaned_value=${BASH_REMATCH[2]}
24173   fi
24174 
24175   if test $cleaned_value -gt 255; then
24176     as_fn_error $? "VERSION_SECURITY is given as $with_version_security. This is greater than 255 which is not allowed." "$LINENO" 5
24177   fi
24178   if test "x$cleaned_value" != "x$with_version_security"; then
24179     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Value for VERSION_SECURITY has been sanitized from '$with_version_security' to '$cleaned_value'" >&5
24180 $as_echo "$as_me: WARNING: Value for VERSION_SECURITY has been sanitized from '$with_version_security' to '$cleaned_value'" >&2;}
24181   fi
24182   VERSION_SECURITY=$cleaned_value
24183 
24184     fi
24185   else
24186     if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
24187       # Default is 0, if unspecified
24188       VERSION_SECURITY=0
24189     fi
24190   fi
24191 
24192 
24193 # Check whether --with-version-patch was given.
24194 if test "${with_version_patch+set}" = set; then :
24195   withval=$with_version_patch; with_version_patch_present=true
24196 else
24197   with_version_patch_present=false
24198 fi
24199 
24200 
24201   if test "x$with_version_patch_present" = xtrue; then
24202     if test "x$with_version_patch" = xyes; then
24203       as_fn_error $? "--with-version-patch must have a value" "$LINENO" 5
24204     elif test "x$with_version_patch" = xno; then
24205       # Interpret --without-* as empty string (i.e. 0) instead of the literal "no"
24206       VERSION_PATCH=0
24207     elif test "x$with_version_patch" = x; then
24208       VERSION_PATCH=0
24209     else
24210 
24211   # Additional [] needed to keep m4 from mangling shell constructs.
24212   if  ! [[ "$with_version_patch" =~ ^0*([1-9][0-9]*)|(0)$ ]]  ; then
24213     as_fn_error $? "\"$with_version_patch\" is not a valid numerical value for VERSION_PATCH" "$LINENO" 5
24214   fi
24215   # Extract the version number without leading zeros.
24216   cleaned_value=${BASH_REMATCH[1]}
24217   if test "x$cleaned_value" = x; then
24218     # Special case for zero
24219     cleaned_value=${BASH_REMATCH[2]}
24220   fi
24221 
24222   if test $cleaned_value -gt 255; then
24223     as_fn_error $? "VERSION_PATCH is given as $with_version_patch. This is greater than 255 which is not allowed." "$LINENO" 5
24224   fi
24225   if test "x$cleaned_value" != "x$with_version_patch"; then
24226     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Value for VERSION_PATCH has been sanitized from '$with_version_patch' to '$cleaned_value'" >&5
24227 $as_echo "$as_me: WARNING: Value for VERSION_PATCH has been sanitized from '$with_version_patch' to '$cleaned_value'" >&2;}
24228   fi
24229   VERSION_PATCH=$cleaned_value
24230 
24231     fi
24232   else
24233     if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
24234       # Default is 0, if unspecified
24235       VERSION_PATCH=0
24236     fi
24237   fi
24238 
24239   # Calculate derived version properties
24240 
24241   # Set VERSION_IS_GA based on if VERSION_PRE has a value
24242   if test "x$VERSION_PRE" = x; then
24243     VERSION_IS_GA=true
24244   else
24245     VERSION_IS_GA=false
24246   fi
24247 
24248   # VERSION_NUMBER but always with exactly 4 positions, with 0 for empty positions.
24249   VERSION_NUMBER_FOUR_POSITIONS=$VERSION_MAJOR.$VERSION_MINOR.$VERSION_SECURITY.$VERSION_PATCH
24250 
24251   stripped_version_number=$VERSION_NUMBER_FOUR_POSITIONS
24252   # Strip trailing zeroes from stripped_version_number
24253   for i in 1 2 3 ; do stripped_version_number=${stripped_version_number%.0} ; done
24254   VERSION_NUMBER=$stripped_version_number
24255 
24256   # The complete version string, with additional build information
24257   if test "x$VERSION_BUILD$VERSION_OPT" = x; then
24258     VERSION_STRING=$VERSION_NUMBER${VERSION_PRE:+-$VERSION_PRE}
24259   else
24260     # If either build or opt is set, we need a + separator
24261     VERSION_STRING=$VERSION_NUMBER${VERSION_PRE:+-$VERSION_PRE}+$VERSION_BUILD${VERSION_OPT:+-$VERSION_OPT}
24262   fi
24263 
24264   # The short version string, just VERSION_NUMBER and PRE, if present.
24265   VERSION_SHORT=$VERSION_NUMBER${VERSION_PRE:+-$VERSION_PRE}
24266 
24267   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for version string" >&5
24268 $as_echo_n "checking for version string... " >&6; }
24269   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $VERSION_STRING" >&5
24270 $as_echo "$VERSION_STRING" >&6; }
24271 
24272 
24273 
24274 
24275 
24276 
24277 
24278 
24279 
24280 
24281 
24282 
24283 
24284 
24285 
24286 ###############################################################################
24287 #
24288 # Setup BootJDK, used to bootstrap the build.
24289 #
24290 ###############################################################################
24291 
24292 
24293   BOOT_JDK_FOUND=no
24294 
24295 # Check whether --with-boot-jdk was given.
24296 if test "${with_boot_jdk+set}" = set; then :
24297   withval=$with_boot_jdk;
24298 fi
24299 
24300 
24301   # We look for the Boot JDK through various means, going from more certain to
24302   # more of a guess-work. After each test, BOOT_JDK_FOUND is set to "yes" if
24303   # we detected something (if so, the path to the jdk is in BOOT_JDK). But we
24304   # must check if this is indeed valid; otherwise we'll continue looking.
24305 
24306   # Test: Is bootjdk explicitely set by command line arguments?
24307 
24308   if test "x$BOOT_JDK_FOUND" = xno; then
24309     # Now execute the test
24310 
24311   if test "x$with_boot_jdk" != x; then
24312     BOOT_JDK=$with_boot_jdk
24313     BOOT_JDK_FOUND=maybe
24314     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using configure arguments" >&5
24315 $as_echo "$as_me: Found potential Boot JDK using configure arguments" >&6;}
24316   fi
24317 
24318 
24319     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24320     if test "x$BOOT_JDK_FOUND" = xmaybe; then
24321       # Do we have a bin/java?
24322       if test ! -x "$BOOT_JDK/bin/java"; then
24323         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24324 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24325         BOOT_JDK_FOUND=no
24326       else
24327         # Do we have a bin/javac?
24328         if test ! -x "$BOOT_JDK/bin/javac"; then
24329           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24330 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24331           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24332 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24333           BOOT_JDK_FOUND=no
24334         else
24335           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24336           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24337 
24338           # Extra M4 quote needed to protect [] in grep expression.
24339           FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
24340           if test "x$FOUND_CORRECT_VERSION" = x; then
24341             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24342 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24343             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
24344 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
24345             BOOT_JDK_FOUND=no
24346           else
24347             # We're done! :-)
24348             BOOT_JDK_FOUND=yes
24349 
24350   # Only process if variable expands to non-empty
24351 
24352   if test "x$BOOT_JDK" != x; then
24353     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24354 
24355   # Input might be given as Windows format, start by converting to
24356   # unix format.
24357   path="$BOOT_JDK"
24358   new_path=`$CYGPATH -u "$path"`
24359 
24360   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24361   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24362   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24363   # "foo.exe" is OK but "foo" is an error.
24364   #
24365   # This test is therefore slightly more accurate than "test -f" to check for file precense.
24366   # It is also a way to make sure we got the proper file name for the real test later on.
24367   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24368   if test "x$test_shortpath" = x; then
24369     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24370 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24371     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24372   fi
24373 
24374   # Call helper function which possibly converts this using DOS-style short mode.
24375   # If so, the updated path is stored in $new_path.
24376 
24377   input_path="$new_path"
24378   # Check if we need to convert this using DOS-style short mode. If the path
24379   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24380   # take no chances and rewrite it.
24381   # Note: m4 eats our [], so we need to use [ and ] instead.
24382   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24383   if test "x$has_forbidden_chars" != x; then
24384     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24385     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24386     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24387     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24388       # Going to short mode and back again did indeed matter. Since short mode is
24389       # case insensitive, let's make it lowercase to improve readability.
24390       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24391       # Now convert it back to Unix-style (cygpath)
24392       input_path=`$CYGPATH -u "$shortmode_path"`
24393       new_path="$input_path"
24394     fi
24395   fi
24396 
24397   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24398   if test "x$test_cygdrive_prefix" = x; then
24399     # As a simple fix, exclude /usr/bin since it's not a real path.
24400     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24401       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24402       # a path prefixed by /cygdrive for fixpath to work.
24403       new_path="$CYGWIN_ROOT_PATH$input_path"
24404     fi
24405   fi
24406 
24407 
24408   if test "x$path" != "x$new_path"; then
24409     BOOT_JDK="$new_path"
24410     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24411 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24412   fi
24413 
24414     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24415 
24416   path="$BOOT_JDK"
24417   has_colon=`$ECHO $path | $GREP ^.:`
24418   new_path="$path"
24419   if test "x$has_colon" = x; then
24420     # Not in mixed or Windows style, start by that.
24421     new_path=`cmd //c echo $path`
24422   fi
24423 
24424 
24425   input_path="$new_path"
24426   # Check if we need to convert this using DOS-style short mode. If the path
24427   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24428   # take no chances and rewrite it.
24429   # Note: m4 eats our [], so we need to use [ and ] instead.
24430   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24431   if test "x$has_forbidden_chars" != x; then
24432     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24433     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24434   fi
24435 
24436 
24437   windows_path="$new_path"
24438   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24439     unix_path=`$CYGPATH -u "$windows_path"`
24440     new_path="$unix_path"
24441   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24442     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24443     new_path="$unix_path"
24444   fi
24445 
24446   if test "x$path" != "x$new_path"; then
24447     BOOT_JDK="$new_path"
24448     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24449 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24450   fi
24451 
24452   # Save the first 10 bytes of this path to the storage, so fixpath can work.
24453   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24454 
24455     else
24456       # We're on a unix platform. Hooray! :)
24457       path="$BOOT_JDK"
24458       has_space=`$ECHO "$path" | $GREP " "`
24459       if test "x$has_space" != x; then
24460         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24461 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24462         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24463       fi
24464 
24465       # Use eval to expand a potential ~
24466       eval path="$path"
24467       if test ! -f "$path" && test ! -d "$path"; then
24468         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24469       fi
24470 
24471       if test -d "$path"; then
24472         BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24473       else
24474         dir="`$DIRNAME "$path"`"
24475         base="`$BASENAME "$path"`"
24476         BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
24477       fi
24478     fi
24479   fi
24480 
24481             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24482 $as_echo_n "checking for Boot JDK... " >&6; }
24483             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24484 $as_echo "$BOOT_JDK" >&6; }
24485             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24486 $as_echo_n "checking Boot JDK version... " >&6; }
24487             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
24488             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24489 $as_echo "$BOOT_JDK_VERSION" >&6; }
24490           fi # end check jdk version
24491         fi # end check javac
24492       fi # end check java
24493     fi # end check boot jdk found
24494   fi
24495 
24496   if test "x$with_boot_jdk" != x && test "x$BOOT_JDK_FOUND" = xno; then
24497     # Having specified an argument which is incorrect will produce an instant failure;
24498     # we should not go on looking
24499     as_fn_error $? "The path given by --with-boot-jdk does not contain a valid Boot JDK" "$LINENO" 5
24500   fi
24501 
24502   # Test: On MacOS X, can we find a boot jdk using /usr/libexec/java_home?
24503 
24504   if test "x$BOOT_JDK_FOUND" = xno; then
24505     # Now execute the test
24506 
24507   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
24508     # First check at user selected default
24509 
24510   if test "x$BOOT_JDK_FOUND" = xno; then
24511     # Now execute the test
24512 
24513   if test -x /usr/libexec/java_home; then
24514     BOOT_JDK=`/usr/libexec/java_home `
24515     BOOT_JDK_FOUND=maybe
24516     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home " >&5
24517 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home " >&6;}
24518   fi
24519 
24520 
24521     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24522     if test "x$BOOT_JDK_FOUND" = xmaybe; then
24523       # Do we have a bin/java?
24524       if test ! -x "$BOOT_JDK/bin/java"; then
24525         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24526 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24527         BOOT_JDK_FOUND=no
24528       else
24529         # Do we have a bin/javac?
24530         if test ! -x "$BOOT_JDK/bin/javac"; then
24531           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24532 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24533           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24534 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24535           BOOT_JDK_FOUND=no
24536         else
24537           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24538           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24539 
24540           # Extra M4 quote needed to protect [] in grep expression.
24541           FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
24542           if test "x$FOUND_CORRECT_VERSION" = x; then
24543             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24544 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24545             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
24546 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
24547             BOOT_JDK_FOUND=no
24548           else
24549             # We're done! :-)
24550             BOOT_JDK_FOUND=yes
24551 
24552   # Only process if variable expands to non-empty
24553 
24554   if test "x$BOOT_JDK" != x; then
24555     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24556 
24557   # Input might be given as Windows format, start by converting to
24558   # unix format.
24559   path="$BOOT_JDK"
24560   new_path=`$CYGPATH -u "$path"`
24561 
24562   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24563   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24564   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24565   # "foo.exe" is OK but "foo" is an error.
24566   #
24567   # This test is therefore slightly more accurate than "test -f" to check for file precense.
24568   # It is also a way to make sure we got the proper file name for the real test later on.
24569   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24570   if test "x$test_shortpath" = x; then
24571     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24572 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24573     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24574   fi
24575 
24576   # Call helper function which possibly converts this using DOS-style short mode.
24577   # If so, the updated path is stored in $new_path.
24578 
24579   input_path="$new_path"
24580   # Check if we need to convert this using DOS-style short mode. If the path
24581   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24582   # take no chances and rewrite it.
24583   # Note: m4 eats our [], so we need to use [ and ] instead.
24584   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24585   if test "x$has_forbidden_chars" != x; then
24586     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24587     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24588     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24589     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24590       # Going to short mode and back again did indeed matter. Since short mode is
24591       # case insensitive, let's make it lowercase to improve readability.
24592       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24593       # Now convert it back to Unix-style (cygpath)
24594       input_path=`$CYGPATH -u "$shortmode_path"`
24595       new_path="$input_path"
24596     fi
24597   fi
24598 
24599   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24600   if test "x$test_cygdrive_prefix" = x; then
24601     # As a simple fix, exclude /usr/bin since it's not a real path.
24602     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24603       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24604       # a path prefixed by /cygdrive for fixpath to work.
24605       new_path="$CYGWIN_ROOT_PATH$input_path"
24606     fi
24607   fi
24608 
24609 
24610   if test "x$path" != "x$new_path"; then
24611     BOOT_JDK="$new_path"
24612     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24613 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24614   fi
24615 
24616     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24617 
24618   path="$BOOT_JDK"
24619   has_colon=`$ECHO $path | $GREP ^.:`
24620   new_path="$path"
24621   if test "x$has_colon" = x; then
24622     # Not in mixed or Windows style, start by that.
24623     new_path=`cmd //c echo $path`
24624   fi
24625 
24626 
24627   input_path="$new_path"
24628   # Check if we need to convert this using DOS-style short mode. If the path
24629   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24630   # take no chances and rewrite it.
24631   # Note: m4 eats our [], so we need to use [ and ] instead.
24632   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24633   if test "x$has_forbidden_chars" != x; then
24634     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24635     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24636   fi
24637 
24638 
24639   windows_path="$new_path"
24640   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24641     unix_path=`$CYGPATH -u "$windows_path"`
24642     new_path="$unix_path"
24643   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24644     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24645     new_path="$unix_path"
24646   fi
24647 
24648   if test "x$path" != "x$new_path"; then
24649     BOOT_JDK="$new_path"
24650     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24651 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24652   fi
24653 
24654   # Save the first 10 bytes of this path to the storage, so fixpath can work.
24655   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24656 
24657     else
24658       # We're on a unix platform. Hooray! :)
24659       path="$BOOT_JDK"
24660       has_space=`$ECHO "$path" | $GREP " "`
24661       if test "x$has_space" != x; then
24662         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24663 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24664         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24665       fi
24666 
24667       # Use eval to expand a potential ~
24668       eval path="$path"
24669       if test ! -f "$path" && test ! -d "$path"; then
24670         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24671       fi
24672 
24673       if test -d "$path"; then
24674         BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24675       else
24676         dir="`$DIRNAME "$path"`"
24677         base="`$BASENAME "$path"`"
24678         BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
24679       fi
24680     fi
24681   fi
24682 
24683             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24684 $as_echo_n "checking for Boot JDK... " >&6; }
24685             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24686 $as_echo "$BOOT_JDK" >&6; }
24687             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24688 $as_echo_n "checking Boot JDK version... " >&6; }
24689             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
24690             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24691 $as_echo "$BOOT_JDK_VERSION" >&6; }
24692           fi # end check jdk version
24693         fi # end check javac
24694       fi # end check java
24695     fi # end check boot jdk found
24696   fi
24697 
24698     # If that did not work out (e.g. too old), try explicit versions instead
24699 
24700   if test "x$BOOT_JDK_FOUND" = xno; then
24701     # Now execute the test
24702 
24703   if test -x /usr/libexec/java_home; then
24704     BOOT_JDK=`/usr/libexec/java_home -v 1.9`
24705     BOOT_JDK_FOUND=maybe
24706     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home -v 1.9" >&5
24707 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home -v 1.9" >&6;}
24708   fi
24709 
24710 
24711     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24712     if test "x$BOOT_JDK_FOUND" = xmaybe; then
24713       # Do we have a bin/java?
24714       if test ! -x "$BOOT_JDK/bin/java"; then
24715         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24716 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24717         BOOT_JDK_FOUND=no
24718       else
24719         # Do we have a bin/javac?
24720         if test ! -x "$BOOT_JDK/bin/javac"; then
24721           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24722 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24723           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24724 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24725           BOOT_JDK_FOUND=no
24726         else
24727           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24728           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24729 
24730           # Extra M4 quote needed to protect [] in grep expression.
24731           FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
24732           if test "x$FOUND_CORRECT_VERSION" = x; then
24733             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24734 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24735             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
24736 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
24737             BOOT_JDK_FOUND=no
24738           else
24739             # We're done! :-)
24740             BOOT_JDK_FOUND=yes
24741 
24742   # Only process if variable expands to non-empty
24743 
24744   if test "x$BOOT_JDK" != x; then
24745     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24746 
24747   # Input might be given as Windows format, start by converting to
24748   # unix format.
24749   path="$BOOT_JDK"
24750   new_path=`$CYGPATH -u "$path"`
24751 
24752   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24753   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24754   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24755   # "foo.exe" is OK but "foo" is an error.
24756   #
24757   # This test is therefore slightly more accurate than "test -f" to check for file precense.
24758   # It is also a way to make sure we got the proper file name for the real test later on.
24759   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24760   if test "x$test_shortpath" = x; then
24761     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24762 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24763     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24764   fi
24765 
24766   # Call helper function which possibly converts this using DOS-style short mode.
24767   # If so, the updated path is stored in $new_path.
24768 
24769   input_path="$new_path"
24770   # Check if we need to convert this using DOS-style short mode. If the path
24771   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24772   # take no chances and rewrite it.
24773   # Note: m4 eats our [], so we need to use [ and ] instead.
24774   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24775   if test "x$has_forbidden_chars" != x; then
24776     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24777     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24778     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24779     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24780       # Going to short mode and back again did indeed matter. Since short mode is
24781       # case insensitive, let's make it lowercase to improve readability.
24782       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24783       # Now convert it back to Unix-style (cygpath)
24784       input_path=`$CYGPATH -u "$shortmode_path"`
24785       new_path="$input_path"
24786     fi
24787   fi
24788 
24789   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24790   if test "x$test_cygdrive_prefix" = x; then
24791     # As a simple fix, exclude /usr/bin since it's not a real path.
24792     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24793       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24794       # a path prefixed by /cygdrive for fixpath to work.
24795       new_path="$CYGWIN_ROOT_PATH$input_path"
24796     fi
24797   fi
24798 
24799 
24800   if test "x$path" != "x$new_path"; then
24801     BOOT_JDK="$new_path"
24802     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24803 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24804   fi
24805 
24806     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24807 
24808   path="$BOOT_JDK"
24809   has_colon=`$ECHO $path | $GREP ^.:`
24810   new_path="$path"
24811   if test "x$has_colon" = x; then
24812     # Not in mixed or Windows style, start by that.
24813     new_path=`cmd //c echo $path`
24814   fi
24815 
24816 
24817   input_path="$new_path"
24818   # Check if we need to convert this using DOS-style short mode. If the path
24819   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24820   # take no chances and rewrite it.
24821   # Note: m4 eats our [], so we need to use [ and ] instead.
24822   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24823   if test "x$has_forbidden_chars" != x; then
24824     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24825     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24826   fi
24827 
24828 
24829   windows_path="$new_path"
24830   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24831     unix_path=`$CYGPATH -u "$windows_path"`
24832     new_path="$unix_path"
24833   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24834     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24835     new_path="$unix_path"
24836   fi
24837 
24838   if test "x$path" != "x$new_path"; then
24839     BOOT_JDK="$new_path"
24840     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24841 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24842   fi
24843 
24844   # Save the first 10 bytes of this path to the storage, so fixpath can work.
24845   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24846 
24847     else
24848       # We're on a unix platform. Hooray! :)
24849       path="$BOOT_JDK"
24850       has_space=`$ECHO "$path" | $GREP " "`
24851       if test "x$has_space" != x; then
24852         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24853 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24854         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24855       fi
24856 
24857       # Use eval to expand a potential ~
24858       eval path="$path"
24859       if test ! -f "$path" && test ! -d "$path"; then
24860         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24861       fi
24862 
24863       if test -d "$path"; then
24864         BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24865       else
24866         dir="`$DIRNAME "$path"`"
24867         base="`$BASENAME "$path"`"
24868         BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
24869       fi
24870     fi
24871   fi
24872 
24873             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24874 $as_echo_n "checking for Boot JDK... " >&6; }
24875             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24876 $as_echo "$BOOT_JDK" >&6; }
24877             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24878 $as_echo_n "checking Boot JDK version... " >&6; }
24879             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
24880             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24881 $as_echo "$BOOT_JDK_VERSION" >&6; }
24882           fi # end check jdk version
24883         fi # end check javac
24884       fi # end check java
24885     fi # end check boot jdk found
24886   fi
24887 
24888 
24889   if test "x$BOOT_JDK_FOUND" = xno; then
24890     # Now execute the test
24891 
24892   if test -x /usr/libexec/java_home; then
24893     BOOT_JDK=`/usr/libexec/java_home -v 1.8`
24894     BOOT_JDK_FOUND=maybe
24895     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home -v 1.8" >&5
24896 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home -v 1.8" >&6;}
24897   fi
24898 
24899 
24900     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24901     if test "x$BOOT_JDK_FOUND" = xmaybe; then
24902       # Do we have a bin/java?
24903       if test ! -x "$BOOT_JDK/bin/java"; then
24904         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24905 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24906         BOOT_JDK_FOUND=no
24907       else
24908         # Do we have a bin/javac?
24909         if test ! -x "$BOOT_JDK/bin/javac"; then
24910           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24911 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24912           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24913 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24914           BOOT_JDK_FOUND=no
24915         else
24916           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24917           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24918 
24919           # Extra M4 quote needed to protect [] in grep expression.
24920           FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
24921           if test "x$FOUND_CORRECT_VERSION" = x; then
24922             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24923 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24924             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
24925 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
24926             BOOT_JDK_FOUND=no
24927           else
24928             # We're done! :-)
24929             BOOT_JDK_FOUND=yes
24930 
24931   # Only process if variable expands to non-empty
24932 
24933   if test "x$BOOT_JDK" != x; then
24934     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24935 
24936   # Input might be given as Windows format, start by converting to
24937   # unix format.
24938   path="$BOOT_JDK"
24939   new_path=`$CYGPATH -u "$path"`
24940 
24941   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24942   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24943   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24944   # "foo.exe" is OK but "foo" is an error.
24945   #
24946   # This test is therefore slightly more accurate than "test -f" to check for file precense.
24947   # It is also a way to make sure we got the proper file name for the real test later on.
24948   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24949   if test "x$test_shortpath" = x; then
24950     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24951 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24952     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24953   fi
24954 
24955   # Call helper function which possibly converts this using DOS-style short mode.
24956   # If so, the updated path is stored in $new_path.
24957 
24958   input_path="$new_path"
24959   # Check if we need to convert this using DOS-style short mode. If the path
24960   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24961   # take no chances and rewrite it.
24962   # Note: m4 eats our [], so we need to use [ and ] instead.
24963   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24964   if test "x$has_forbidden_chars" != x; then
24965     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24966     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24967     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24968     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24969       # Going to short mode and back again did indeed matter. Since short mode is
24970       # case insensitive, let's make it lowercase to improve readability.
24971       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24972       # Now convert it back to Unix-style (cygpath)
24973       input_path=`$CYGPATH -u "$shortmode_path"`
24974       new_path="$input_path"
24975     fi
24976   fi
24977 
24978   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24979   if test "x$test_cygdrive_prefix" = x; then
24980     # As a simple fix, exclude /usr/bin since it's not a real path.
24981     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24982       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24983       # a path prefixed by /cygdrive for fixpath to work.
24984       new_path="$CYGWIN_ROOT_PATH$input_path"
24985     fi
24986   fi
24987 
24988 
24989   if test "x$path" != "x$new_path"; then
24990     BOOT_JDK="$new_path"
24991     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24992 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24993   fi
24994 
24995     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24996 
24997   path="$BOOT_JDK"
24998   has_colon=`$ECHO $path | $GREP ^.:`
24999   new_path="$path"
25000   if test "x$has_colon" = x; then
25001     # Not in mixed or Windows style, start by that.
25002     new_path=`cmd //c echo $path`
25003   fi
25004 
25005 
25006   input_path="$new_path"
25007   # Check if we need to convert this using DOS-style short mode. If the path
25008   # contains just simple characters, use it. Otherwise (spaces, weird characters),
25009   # take no chances and rewrite it.
25010   # Note: m4 eats our [], so we need to use [ and ] instead.
25011   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
25012   if test "x$has_forbidden_chars" != x; then
25013     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
25014     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
25015   fi
25016 
25017 
25018   windows_path="$new_path"
25019   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
25020     unix_path=`$CYGPATH -u "$windows_path"`
25021     new_path="$unix_path"
25022   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
25023     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
25024     new_path="$unix_path"
25025   fi
25026 
25027   if test "x$path" != "x$new_path"; then
25028     BOOT_JDK="$new_path"
25029     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
25030 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
25031   fi
25032 
25033   # Save the first 10 bytes of this path to the storage, so fixpath can work.
25034   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
25035 
25036     else
25037       # We're on a unix platform. Hooray! :)
25038       path="$BOOT_JDK"
25039       has_space=`$ECHO "$path" | $GREP " "`
25040       if test "x$has_space" != x; then
25041         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
25042 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
25043         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
25044       fi
25045 
25046       # Use eval to expand a potential ~
25047       eval path="$path"
25048       if test ! -f "$path" && test ! -d "$path"; then
25049         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
25050       fi
25051 
25052       if test -d "$path"; then
25053         BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
25054       else
25055         dir="`$DIRNAME "$path"`"
25056         base="`$BASENAME "$path"`"
25057         BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
25058       fi
25059     fi
25060   fi
25061 
25062             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
25063 $as_echo_n "checking for Boot JDK... " >&6; }
25064             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
25065 $as_echo "$BOOT_JDK" >&6; }
25066             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
25067 $as_echo_n "checking Boot JDK version... " >&6; }
25068             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
25069             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
25070 $as_echo "$BOOT_JDK_VERSION" >&6; }
25071           fi # end check jdk version
25072         fi # end check javac
25073       fi # end check java
25074     fi # end check boot jdk found
25075   fi
25076 
25077 
25078   if test "x$BOOT_JDK_FOUND" = xno; then
25079     # Now execute the test
25080 
25081   if test -x /usr/libexec/java_home; then
25082     BOOT_JDK=`/usr/libexec/java_home -v 1.7`
25083     BOOT_JDK_FOUND=maybe
25084     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home -v 1.7" >&5
25085 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home -v 1.7" >&6;}
25086   fi
25087 
25088 
25089     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
25090     if test "x$BOOT_JDK_FOUND" = xmaybe; then
25091       # Do we have a bin/java?
25092       if test ! -x "$BOOT_JDK/bin/java"; then
25093         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
25094 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
25095         BOOT_JDK_FOUND=no
25096       else
25097         # Do we have a bin/javac?
25098         if test ! -x "$BOOT_JDK/bin/javac"; then
25099           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
25100 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
25101           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
25102 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
25103           BOOT_JDK_FOUND=no
25104         else
25105           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
25106           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
25107 
25108           # Extra M4 quote needed to protect [] in grep expression.
25109           FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
25110           if test "x$FOUND_CORRECT_VERSION" = x; then
25111             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
25112 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
25113             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
25114 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
25115             BOOT_JDK_FOUND=no
25116           else
25117             # We're done! :-)
25118             BOOT_JDK_FOUND=yes
25119 
25120   # Only process if variable expands to non-empty
25121 
25122   if test "x$BOOT_JDK" != x; then
25123     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
25124 
25125   # Input might be given as Windows format, start by converting to
25126   # unix format.
25127   path="$BOOT_JDK"
25128   new_path=`$CYGPATH -u "$path"`
25129 
25130   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
25131   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
25132   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
25133   # "foo.exe" is OK but "foo" is an error.
25134   #
25135   # This test is therefore slightly more accurate than "test -f" to check for file precense.
25136   # It is also a way to make sure we got the proper file name for the real test later on.
25137   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
25138   if test "x$test_shortpath" = x; then
25139     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
25140 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
25141     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
25142   fi
25143 
25144   # Call helper function which possibly converts this using DOS-style short mode.
25145   # If so, the updated path is stored in $new_path.
25146 
25147   input_path="$new_path"
25148   # Check if we need to convert this using DOS-style short mode. If the path
25149   # contains just simple characters, use it. Otherwise (spaces, weird characters),
25150   # take no chances and rewrite it.
25151   # Note: m4 eats our [], so we need to use [ and ] instead.
25152   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
25153   if test "x$has_forbidden_chars" != x; then
25154     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
25155     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
25156     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
25157     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
25158       # Going to short mode and back again did indeed matter. Since short mode is
25159       # case insensitive, let's make it lowercase to improve readability.
25160       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
25161       # Now convert it back to Unix-style (cygpath)
25162       input_path=`$CYGPATH -u "$shortmode_path"`
25163       new_path="$input_path"
25164     fi
25165   fi
25166 
25167   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
25168   if test "x$test_cygdrive_prefix" = x; then
25169     # As a simple fix, exclude /usr/bin since it's not a real path.
25170     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
25171       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
25172       # a path prefixed by /cygdrive for fixpath to work.
25173       new_path="$CYGWIN_ROOT_PATH$input_path"
25174     fi
25175   fi
25176 
25177 
25178   if test "x$path" != "x$new_path"; then
25179     BOOT_JDK="$new_path"
25180     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
25181 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
25182   fi
25183 
25184     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
25185 
25186   path="$BOOT_JDK"
25187   has_colon=`$ECHO $path | $GREP ^.:`
25188   new_path="$path"
25189   if test "x$has_colon" = x; then
25190     # Not in mixed or Windows style, start by that.
25191     new_path=`cmd //c echo $path`
25192   fi
25193 
25194 
25195   input_path="$new_path"
25196   # Check if we need to convert this using DOS-style short mode. If the path
25197   # contains just simple characters, use it. Otherwise (spaces, weird characters),
25198   # take no chances and rewrite it.
25199   # Note: m4 eats our [], so we need to use [ and ] instead.
25200   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
25201   if test "x$has_forbidden_chars" != x; then
25202     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
25203     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
25204   fi
25205 
25206 
25207   windows_path="$new_path"
25208   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
25209     unix_path=`$CYGPATH -u "$windows_path"`
25210     new_path="$unix_path"
25211   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
25212     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
25213     new_path="$unix_path"
25214   fi
25215 
25216   if test "x$path" != "x$new_path"; then
25217     BOOT_JDK="$new_path"
25218     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
25219 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
25220   fi
25221 
25222   # Save the first 10 bytes of this path to the storage, so fixpath can work.
25223   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
25224 
25225     else
25226       # We're on a unix platform. Hooray! :)
25227       path="$BOOT_JDK"
25228       has_space=`$ECHO "$path" | $GREP " "`
25229       if test "x$has_space" != x; then
25230         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
25231 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
25232         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
25233       fi
25234 
25235       # Use eval to expand a potential ~
25236       eval path="$path"
25237       if test ! -f "$path" && test ! -d "$path"; then
25238         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
25239       fi
25240 
25241       if test -d "$path"; then
25242         BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
25243       else
25244         dir="`$DIRNAME "$path"`"
25245         base="`$BASENAME "$path"`"
25246         BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
25247       fi
25248     fi
25249   fi
25250 
25251             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
25252 $as_echo_n "checking for Boot JDK... " >&6; }
25253             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
25254 $as_echo "$BOOT_JDK" >&6; }
25255             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
25256 $as_echo_n "checking Boot JDK version... " >&6; }
25257             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
25258             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
25259 $as_echo "$BOOT_JDK_VERSION" >&6; }
25260           fi # end check jdk version
25261         fi # end check javac
25262