1 #!/bin/bash
   2 #
   3 # ##########################################################
   4 # ### THIS FILE IS AUTOMATICALLY GENERATED. DO NOT EDIT. ###
   5 # ##########################################################
   6 #
   7 #! /bin/sh
   8 # Guess values for system-dependent variables and create Makefiles.
   9 # Generated by GNU Autoconf 2.69 for OpenJDK jdk9.
  10 #
  11 # Report bugs to <build-dev@openjdk.java.net>.
  12 #
  13 #
  14 # Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
  15 #
  16 #
  17 # This configure script is free software; the Free Software Foundation
  18 # gives unlimited permission to copy, distribute and modify it.
  19 ## -------------------- ##
  20 ## M4sh Initialization. ##
  21 ## -------------------- ##
  22 
  23 # Be more Bourne compatible
  24 DUALCASE=1; export DUALCASE # for MKS sh
  25 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
  26   emulate sh
  27   NULLCMD=:
  28   # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
  29   # is contrary to our usage.  Disable this feature.
  30   alias -g '${1+"$@"}'='"$@"'
  31   setopt NO_GLOB_SUBST
  32 else
  33   case `(set -o) 2>/dev/null` in #(
  34   *posix*) :
  35     set -o posix ;; #(
  36   *) :
  37      ;;
  38 esac
  39 fi
  40 
  41 
  42 as_nl='
  43 '
  44 export as_nl
  45 # Printing a long string crashes Solaris 7 /usr/bin/printf.
  46 as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
  47 as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
  48 as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
  49 # Prefer a ksh shell builtin over an external printf program on Solaris,
  50 # but without wasting forks for bash or zsh.
  51 if test -z "$BASH_VERSION$ZSH_VERSION" \
  52     && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
  53   as_echo='print -r --'
  54   as_echo_n='print -rn --'
  55 elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
  56   as_echo='printf %s\n'
  57   as_echo_n='printf %s'
  58 else
  59   if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
  60     as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
  61     as_echo_n='/usr/ucb/echo -n'
  62   else
  63     as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
  64     as_echo_n_body='eval
  65       arg=$1;
  66       case $arg in #(
  67       *"$as_nl"*)
  68         expr "X$arg" : "X\\(.*\\)$as_nl";
  69         arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
  70       esac;
  71       expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
  72     '
  73     export as_echo_n_body
  74     as_echo_n='sh -c $as_echo_n_body as_echo'
  75   fi
  76   export as_echo_body
  77   as_echo='sh -c $as_echo_body as_echo'
  78 fi
  79 
  80 # The user is always right.
  81 if test "${PATH_SEPARATOR+set}" != set; then
  82   PATH_SEPARATOR=:
  83   (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
  84     (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
  85       PATH_SEPARATOR=';'
  86   }
  87 fi
  88 
  89 
  90 # IFS
  91 # We need space, tab and new line, in precisely that order.  Quoting is
  92 # there to prevent editors from complaining about space-tab.
  93 # (If _AS_PATH_WALK were called with IFS unset, it would disable word
  94 # splitting by setting IFS to empty value.)
  95 IFS=" ""        $as_nl"
  96 
  97 # Find who we are.  Look in the path if we contain no directory separator.
  98 as_myself=
  99 case $0 in #((
 100   *[\\/]* ) as_myself=$0 ;;
 101   *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 102 for as_dir in $PATH
 103 do
 104   IFS=$as_save_IFS
 105   test -z "$as_dir" && as_dir=.
 106     test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
 107   done
 108 IFS=$as_save_IFS
 109 
 110      ;;
 111 esac
 112 # We did not find ourselves, most probably we were run as `sh COMMAND'
 113 # in which case we are not to be found in the path.
 114 if test "x$as_myself" = x; then
 115   as_myself=$0
 116 fi
 117 if test ! -f "$as_myself"; then
 118   $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
 119   exit 1
 120 fi
 121 
 122 # Unset variables that we do not need and which cause bugs (e.g. in
 123 # pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
 124 # suppresses any "Segmentation fault" message there.  '((' could
 125 # trigger a bug in pdksh 5.2.14.
 126 for as_var in BASH_ENV ENV MAIL MAILPATH
 127 do eval test x\${$as_var+set} = xset \
 128   && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
 129 done
 130 PS1='$ '
 131 PS2='> '
 132 PS4='+ '
 133 
 134 # NLS nuisances.
 135 LC_ALL=C
 136 export LC_ALL
 137 LANGUAGE=C
 138 export LANGUAGE
 139 
 140 # CDPATH.
 141 (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
 142 
 143 # Use a proper internal environment variable to ensure we don't fall
 144   # into an infinite loop, continuously re-executing ourselves.
 145   if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then
 146     _as_can_reexec=no; export _as_can_reexec;
 147     # We cannot yet assume a decent shell, so we have to provide a
 148 # neutralization value for shells without unset; and this also
 149 # works around shells that cannot unset nonexistent variables.
 150 # Preserve -v and -x to the replacement shell.
 151 BASH_ENV=/dev/null
 152 ENV=/dev/null
 153 (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
 154 case $- in # ((((
 155   *v*x* | *x*v* ) as_opts=-vx ;;
 156   *v* ) as_opts=-v ;;
 157   *x* ) as_opts=-x ;;
 158   * ) as_opts= ;;
 159 esac
 160 exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
 161 # Admittedly, this is quite paranoid, since all the known shells bail
 162 # out after a failed `exec'.
 163 $as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
 164 as_fn_exit 255
 165   fi
 166   # We don't want this to propagate to other subprocesses.
 167           { _as_can_reexec=; unset _as_can_reexec;}
 168 if test "x$CONFIG_SHELL" = x; then
 169   as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then :
 170   emulate sh
 171   NULLCMD=:
 172   # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which
 173   # is contrary to our usage.  Disable this feature.
 174   alias -g '\${1+\"\$@\"}'='\"\$@\"'
 175   setopt NO_GLOB_SUBST
 176 else
 177   case \`(set -o) 2>/dev/null\` in #(
 178   *posix*) :
 179     set -o posix ;; #(
 180   *) :
 181      ;;
 182 esac
 183 fi
 184 "
 185   as_required="as_fn_return () { (exit \$1); }
 186 as_fn_success () { as_fn_return 0; }
 187 as_fn_failure () { as_fn_return 1; }
 188 as_fn_ret_success () { return 0; }
 189 as_fn_ret_failure () { return 1; }
 190 
 191 exitcode=0
 192 as_fn_success || { exitcode=1; echo as_fn_success failed.; }
 193 as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; }
 194 as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; }
 195 as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; }
 196 if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then :
 197 
 198 else
 199   exitcode=1; echo positional parameters were not saved.
 200 fi
 201 test x\$exitcode = x0 || exit 1
 202 test -x / || exit 1"
 203   as_suggested="  as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO
 204   as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO
 205   eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" &&
 206   test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1
 207 test \$(( 1 + 1 )) = 2 || exit 1"
 208   if (eval "$as_required") 2>/dev/null; then :
 209   as_have_required=yes
 210 else
 211   as_have_required=no
 212 fi
 213   if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then :
 214 
 215 else
 216   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 217 as_found=false
 218 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
 219 do
 220   IFS=$as_save_IFS
 221   test -z "$as_dir" && as_dir=.
 222   as_found=:
 223   case $as_dir in #(
 224          /*)
 225            for as_base in sh bash ksh sh5; do
 226              # Try only shells that exist, to save several forks.
 227              as_shell=$as_dir/$as_base
 228              if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
 229                     { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then :
 230   CONFIG_SHELL=$as_shell as_have_required=yes
 231                    if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then :
 232   break 2
 233 fi
 234 fi
 235            done;;
 236        esac
 237   as_found=false
 238 done
 239 $as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } &&
 240               { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then :
 241   CONFIG_SHELL=$SHELL as_have_required=yes
 242 fi; }
 243 IFS=$as_save_IFS
 244 
 245 
 246       if test "x$CONFIG_SHELL" != x; then :
 247   export CONFIG_SHELL
 248              # We cannot yet assume a decent shell, so we have to provide a
 249 # neutralization value for shells without unset; and this also
 250 # works around shells that cannot unset nonexistent variables.
 251 # Preserve -v and -x to the replacement shell.
 252 BASH_ENV=/dev/null
 253 ENV=/dev/null
 254 (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
 255 case $- in # ((((
 256   *v*x* | *x*v* ) as_opts=-vx ;;
 257   *v* ) as_opts=-v ;;
 258   *x* ) as_opts=-x ;;
 259   * ) as_opts= ;;
 260 esac
 261 exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
 262 # Admittedly, this is quite paranoid, since all the known shells bail
 263 # out after a failed `exec'.
 264 $as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
 265 exit 255
 266 fi
 267 
 268     if test x$as_have_required = xno; then :
 269   $as_echo "$0: This script requires a shell more modern than all"
 270   $as_echo "$0: the shells that I found on your system."
 271   if test x${ZSH_VERSION+set} = xset ; then
 272     $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should"
 273     $as_echo "$0: be upgraded to zsh 4.3.4 or later."
 274   else
 275     $as_echo "$0: Please tell bug-autoconf@gnu.org and
 276 $0: build-dev@openjdk.java.net about your system, including
 277 $0: any error possibly output before this message. Then
 278 $0: install a modern shell, or manually run the script
 279 $0: under such a shell if you do have one."
 280   fi
 281   exit 1
 282 fi
 283 fi
 284 fi
 285 SHELL=${CONFIG_SHELL-/bin/sh}
 286 export SHELL
 287 # Unset more variables known to interfere with behavior of common tools.
 288 CLICOLOR_FORCE= GREP_OPTIONS=
 289 unset CLICOLOR_FORCE GREP_OPTIONS
 290 
 291 ## --------------------- ##
 292 ## M4sh Shell Functions. ##
 293 ## --------------------- ##
 294 # as_fn_unset VAR
 295 # ---------------
 296 # Portably unset VAR.
 297 as_fn_unset ()
 298 {
 299   { eval $1=; unset $1;}
 300 }
 301 as_unset=as_fn_unset
 302 
 303 # as_fn_set_status STATUS
 304 # -----------------------
 305 # Set $? to STATUS, without forking.
 306 as_fn_set_status ()
 307 {
 308   return $1
 309 } # as_fn_set_status
 310 
 311 # as_fn_exit STATUS
 312 # -----------------
 313 # Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
 314 as_fn_exit ()
 315 {
 316   set +e
 317   as_fn_set_status $1
 318   exit $1
 319 } # as_fn_exit
 320 
 321 # as_fn_mkdir_p
 322 # -------------
 323 # Create "$as_dir" as a directory, including parents if necessary.
 324 as_fn_mkdir_p ()
 325 {
 326 
 327   case $as_dir in #(
 328   -*) as_dir=./$as_dir;;
 329   esac
 330   test -d "$as_dir" || eval $as_mkdir_p || {
 331     as_dirs=
 332     while :; do
 333       case $as_dir in #(
 334       *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
 335       *) as_qdir=$as_dir;;
 336       esac
 337       as_dirs="'$as_qdir' $as_dirs"
 338       as_dir=`$as_dirname -- "$as_dir" ||
 339 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 340          X"$as_dir" : 'X\(//\)[^/]' \| \
 341          X"$as_dir" : 'X\(//\)$' \| \
 342          X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
 343 $as_echo X"$as_dir" |
 344     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
 345             s//\1/
 346             q
 347           }
 348           /^X\(\/\/\)[^/].*/{
 349             s//\1/
 350             q
 351           }
 352           /^X\(\/\/\)$/{
 353             s//\1/
 354             q
 355           }
 356           /^X\(\/\).*/{
 357             s//\1/
 358             q
 359           }
 360           s/.*/./; q'`
 361       test -d "$as_dir" && break
 362     done
 363     test -z "$as_dirs" || eval "mkdir $as_dirs"
 364   } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
 365 
 366 
 367 } # as_fn_mkdir_p
 368 
 369 # as_fn_executable_p FILE
 370 # -----------------------
 371 # Test if FILE is an executable regular file.
 372 as_fn_executable_p ()
 373 {
 374   test -f "$1" && test -x "$1"
 375 } # as_fn_executable_p
 376 # as_fn_append VAR VALUE
 377 # ----------------------
 378 # Append the text in VALUE to the end of the definition contained in VAR. Take
 379 # advantage of any shell optimizations that allow amortized linear growth over
 380 # repeated appends, instead of the typical quadratic growth present in naive
 381 # implementations.
 382 if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
 383   eval 'as_fn_append ()
 384   {
 385     eval $1+=\$2
 386   }'
 387 else
 388   as_fn_append ()
 389   {
 390     eval $1=\$$1\$2
 391   }
 392 fi # as_fn_append
 393 
 394 # as_fn_arith ARG...
 395 # ------------------
 396 # Perform arithmetic evaluation on the ARGs, and store the result in the
 397 # global $as_val. Take advantage of shells that can avoid forks. The arguments
 398 # must be portable across $(()) and expr.
 399 if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
 400   eval 'as_fn_arith ()
 401   {
 402     as_val=$(( $* ))
 403   }'
 404 else
 405   as_fn_arith ()
 406   {
 407     as_val=`expr "$@" || test $? -eq 1`
 408   }
 409 fi # as_fn_arith
 410 
 411 
 412 # as_fn_error STATUS ERROR [LINENO LOG_FD]
 413 # ----------------------------------------
 414 # Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
 415 # provided, also output the error to LOG_FD, referencing LINENO. Then exit the
 416 # script with STATUS, using 1 if that was 0.
 417 as_fn_error ()
 418 {
 419   as_status=$1; test $as_status -eq 0 && as_status=1
 420   if test "$4"; then
 421     as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
 422     $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
 423   fi
 424   $as_echo "$as_me: error: $2" >&2
 425   as_fn_exit $as_status
 426 } # as_fn_error
 427 
 428 if expr a : '\(a\)' >/dev/null 2>&1 &&
 429    test "X`expr 00001 : '.*\(...\)'`" = X001; then
 430   as_expr=expr
 431 else
 432   as_expr=false
 433 fi
 434 
 435 if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
 436   as_basename=basename
 437 else
 438   as_basename=false
 439 fi
 440 
 441 if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
 442   as_dirname=dirname
 443 else
 444   as_dirname=false
 445 fi
 446 
 447 as_me=`$as_basename -- "$0" ||
 448 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
 449          X"$0" : 'X\(//\)$' \| \
 450          X"$0" : 'X\(/\)' \| . 2>/dev/null ||
 451 $as_echo X/"$0" |
 452     sed '/^.*\/\([^/][^/]*\)\/*$/{
 453             s//\1/
 454             q
 455           }
 456           /^X\/\(\/\/\)$/{
 457             s//\1/
 458             q
 459           }
 460           /^X\/\(\/\).*/{
 461             s//\1/
 462             q
 463           }
 464           s/.*/./; q'`
 465 
 466 # Avoid depending upon Character Ranges.
 467 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
 468 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
 469 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
 470 as_cr_digits='0123456789'
 471 as_cr_alnum=$as_cr_Letters$as_cr_digits
 472 
 473 
 474   as_lineno_1=$LINENO as_lineno_1a=$LINENO
 475   as_lineno_2=$LINENO as_lineno_2a=$LINENO
 476   eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" &&
 477   test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || {
 478   # Blame Lee E. McMahon (1931-1989) for sed's syntax.  :-)
 479   sed -n '
 480     p
 481     /[$]LINENO/=
 482   ' <$as_myself |
 483     sed '
 484       s/[$]LINENO.*/&-/
 485       t lineno
 486       b
 487       :lineno
 488       N
 489       :loop
 490       s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
 491       t loop
 492       s/-\n.*//
 493     ' >$as_me.lineno &&
 494   chmod +x "$as_me.lineno" ||
 495     { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }
 496 
 497   # If we had to re-execute with $CONFIG_SHELL, we're ensured to have
 498   # already done that, so ensure we don't try to do so again and fall
 499   # in an infinite loop.  This has already happened in practice.
 500   _as_can_reexec=no; export _as_can_reexec
 501   # Don't try to exec as it changes $[0], causing all sort of problems
 502   # (the dirname of $[0] is not the place where we might find the
 503   # original and so on.  Autoconf is especially sensitive to this).
 504   . "./$as_me.lineno"
 505   # Exit status is that of the last command.
 506   exit
 507 }
 508 
 509 ECHO_C= ECHO_N= ECHO_T=
 510 case `echo -n x` in #(((((
 511 -n*)
 512   case `echo 'xy\c'` in
 513   *c*) ECHO_T=' ';;     # ECHO_T is single tab character.
 514   xy)  ECHO_C='\c';;
 515   *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
 516        ECHO_T=' ';;
 517   esac;;
 518 *)
 519   ECHO_N='-n';;
 520 esac
 521 
 522 rm -f conf$$ conf$$.exe conf$$.file
 523 if test -d conf$$.dir; then
 524   rm -f conf$$.dir/conf$$.file
 525 else
 526   rm -f conf$$.dir
 527   mkdir conf$$.dir 2>/dev/null
 528 fi
 529 if (echo >conf$$.file) 2>/dev/null; then
 530   if ln -s conf$$.file conf$$ 2>/dev/null; then
 531     as_ln_s='ln -s'
 532     # ... but there are two gotchas:
 533     # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
 534     # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
 535     # In both cases, we have to default to `cp -pR'.
 536     ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
 537       as_ln_s='cp -pR'
 538   elif ln conf$$.file conf$$ 2>/dev/null; then
 539     as_ln_s=ln
 540   else
 541     as_ln_s='cp -pR'
 542   fi
 543 else
 544   as_ln_s='cp -pR'
 545 fi
 546 rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
 547 rmdir conf$$.dir 2>/dev/null
 548 
 549 if mkdir -p . 2>/dev/null; then
 550   as_mkdir_p='mkdir -p "$as_dir"'
 551 else
 552   test -d ./-p && rmdir ./-p
 553   as_mkdir_p=false
 554 fi
 555 
 556 as_test_x='test -x'
 557 as_executable_p=as_fn_executable_p
 558 
 559 # Sed expression to map a string onto a valid CPP name.
 560 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
 561 
 562 # Sed expression to map a string onto a valid variable name.
 563 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
 564 
 565 
 566 test -n "$DJDIR" || exec 7<&0 </dev/null
 567 exec 6>&1
 568 
 569 # Name of the host.
 570 # hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status,
 571 # so uname gets run too.
 572 ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
 573 
 574 #
 575 # Initializations.
 576 #
 577 ac_default_prefix=/usr/local
 578 ac_clean_files=
 579 ac_config_libobj_dir=.
 580 LIBOBJS=
 581 cross_compiling=no
 582 subdirs=
 583 MFLAGS=
 584 MAKEFLAGS=
 585 
 586 # Identity of this package.
 587 PACKAGE_NAME='OpenJDK'
 588 PACKAGE_TARNAME='openjdk'
 589 PACKAGE_VERSION='jdk9'
 590 PACKAGE_STRING='OpenJDK jdk9'
 591 PACKAGE_BUGREPORT='build-dev@openjdk.java.net'
 592 PACKAGE_URL='http://openjdk.java.net'
 593 
 594 # Factoring default headers for most tests.
 595 ac_includes_default="\
 596 #include <stdio.h>
 597 #ifdef HAVE_SYS_TYPES_H
 598 # include <sys/types.h>
 599 #endif
 600 #ifdef HAVE_SYS_STAT_H
 601 # include <sys/stat.h>
 602 #endif
 603 #ifdef STDC_HEADERS
 604 # include <stdlib.h>
 605 # include <stddef.h>
 606 #else
 607 # ifdef HAVE_STDLIB_H
 608 #  include <stdlib.h>
 609 # endif
 610 #endif
 611 #ifdef HAVE_STRING_H
 612 # if !defined STDC_HEADERS && defined HAVE_MEMORY_H
 613 #  include <memory.h>
 614 # endif
 615 # include <string.h>
 616 #endif
 617 #ifdef HAVE_STRINGS_H
 618 # include <strings.h>
 619 #endif
 620 #ifdef HAVE_INTTYPES_H
 621 # include <inttypes.h>
 622 #endif
 623 #ifdef HAVE_STDINT_H
 624 # include <stdint.h>
 625 #endif
 626 #ifdef HAVE_UNISTD_H
 627 # include <unistd.h>
 628 #endif"
 629 
 630 ac_subst_vars='LTLIBOBJS
 631 LIBOBJS
 632 CFLAGS_CCACHE
 633 CCACHE
 634 USE_PRECOMPILED_HEADER
 635 BUILD_ICECC
 636 ICECC
 637 ICECC_WRAPPER
 638 ICECC_CREATE_ENV
 639 ICECC_CMD
 640 ENABLE_JAVAC_SERVER
 641 ENABLE_SJAVAC
 642 SJAVAC_SERVER_JAVA_FLAGS
 643 SJAVAC_SERVER_JAVA
 644 JAVA_TOOL_FLAGS_SMALL
 645 JAVA_FLAGS_SMALL
 646 JAVA_FLAGS_JAVAC
 647 JAVA_FLAGS_BIG
 648 JAVA_FLAGS
 649 JOBS
 650 MEMORY_SIZE
 651 NUM_CORES
 652 ENABLE_INTREE_EC
 653 SALIB_NAME
 654 HOTSPOT_MAKE_ARGS
 655 LIBZIP_CAN_USE_MMAP
 656 LIBDL
 657 LIBM
 658 USE_EXTERNAL_LCMS
 659 LCMS_LIBS
 660 LCMS_CFLAGS
 661 USE_EXTERNAL_LIBZ
 662 USE_EXTERNAL_LIBPNG
 663 PNG_LIBS
 664 PNG_CFLAGS
 665 USE_EXTERNAL_LIBGIF
 666 USE_EXTERNAL_LIBJPEG
 667 LLVM_LIBS
 668 LLVM_LDFLAGS
 669 LLVM_CFLAGS
 670 LLVM_CONFIG
 671 LIBFFI_LIBS
 672 LIBFFI_CFLAGS
 673 ALSA_LIBS
 674 ALSA_CFLAGS
 675 FREETYPE_BUNDLE_LIB_PATH
 676 FREETYPE_LIBS
 677 FREETYPE_CFLAGS
 678 CUPS_CFLAGS
 679 X_EXTRA_LIBS
 680 X_LIBS
 681 X_PRE_LIBS
 682 X_CFLAGS
 683 XMKMF
 684 MSVCP_DLL
 685 MSVCR_DLL
 686 LIBCXX
 687 STATIC_CXX_SETTING
 688 FIXPATH_DETACH_FLAG
 689 FIXPATH
 690 GCOV_ENABLED
 691 ZIP_DEBUGINFO_FILES
 692 ENABLE_DEBUG_SYMBOLS



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

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

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



2000   --with-stdc++lib=<static>,<dynamic>,<default>
2001                           force linking of the C++ runtime on Linux to either
2002                           static or dynamic, default is static with dynamic as
2003                           fallback
2004   --with-msvcr-dll        path to microsoft C runtime dll (msvcr*.dll)
2005                           (Windows only) [probed]
2006   --with-msvcp-dll        path to microsoft C++ runtime dll (msvcp*.dll)
2007                           (Windows only) [probed]
2008   --with-x                use the X Window System
2009   --with-cups             specify prefix directory for the cups package
2010                           (expecting the headers under PATH/include)
2011   --with-cups-include     specify directory for the cups include files
2012   --with-freetype         specify prefix directory for the freetype package
2013                           (expecting the libraries under PATH/lib and the
2014                           headers under PATH/include)
2015   --with-freetype-include specify directory for the freetype include files
2016   --with-freetype-lib     specify directory for the freetype library
2017   --with-freetype-src     specify directory with freetype sources to
2018                           automatically build the library (experimental,
2019                           Windows-only)
2020   --with-alsa             specify prefix directory for the alsa package
2021                           (expecting the libraries under PATH/lib and the
2022                           headers under PATH/include)
2023   --with-alsa-include     specify directory for the alsa include files
2024   --with-alsa-lib         specify directory for the alsa library
2025   --with-libffi           specify prefix directory for the libffi package
2026                           (expecting the libraries under PATH/lib and the
2027                           headers under PATH/include)
2028   --with-libffi-include   specify directory for the libffi include files
2029   --with-libffi-lib       specify directory for the libffi library
2030   --with-libjpeg          use libjpeg from build system or OpenJDK source
2031                           (system, bundled) [bundled]
2032   --with-giflib           use giflib from build system or OpenJDK source
2033                           (system, bundled) [bundled]
2034   --with-libpng           use libpng from build system or OpenJDK source
2035                           (system, bundled) [bundled]
2036   --with-zlib             use zlib from build system or OpenJDK source
2037                           (system, bundled) [bundled]
2038   --with-lcms             use lcms2 from build system or OpenJDK source
2039                           (system, bundled) [bundled]
2040   --with-dxsdk            Deprecated. Option is kept for backwards
2041                           compatibility and is ignored
2042   --with-dxsdk-lib        Deprecated. Option is kept for backwards
2043                           compatibility and is ignored
2044   --with-dxsdk-include    Deprecated. Option is kept for backwards
2045                           compatibility and is ignored
2046   --with-num-cores        number of cores in the build system, e.g.
2047                           --with-num-cores=8 [probed]
2048   --with-memory-size      memory (in MB) available in the build system, e.g.
2049                           --with-memory-size=1024 [probed]
2050   --with-jobs             number of parallel jobs to let make run [calculated
2051                           based on cores and memory]
2052   --with-boot-jdk-jvmargs specify JVM arguments to be passed to all java
2053                           invocations of boot JDK, overriding the default
2054                           values, e.g --with-boot-jdk-jvmargs="-Xmx8G
2055                           -enableassertions"
2056   --with-sjavac-server-java
2057                           use this java binary for running the sjavac
2058                           background server [Boot JDK java]
2059   --with-ccache-dir       where to store ccache files [~/.ccache]
2060 
2061 Some influential environment variables:
2062   BASENAME    Override default value for BASENAME
2063   BASH        Override default value for BASH
2064   CAT         Override default value for CAT
2065   CHMOD       Override default value for CHMOD
2066   CMP         Override default value for CMP
2067   COMM        Override default value for COMM
2068   CP          Override default value for CP
2069   CUT         Override default value for CUT
2070   DATE        Override default value for DATE
2071   DIFF        Override default value for DIFF
2072   DIRNAME     Override default value for DIRNAME
2073   ECHO        Override default value for ECHO
2074   EXPR        Override default value for EXPR
2075   FILE        Override default value for FILE
2076   FIND        Override default value for FIND
2077   HEAD        Override default value for HEAD
2078   LN          Override default value for LN
2079   LS          Override default value for LS
2080   MKDIR       Override default value for MKDIR
2081   MKTEMP      Override default value for MKTEMP
2082   MV          Override default value for MV
2083   NAWK        Override default value for NAWK
2084   PRINTF      Override default value for PRINTF
2085   RM          Override default value for RM
2086   RMDIR       Override default value for RMDIR
2087   SH          Override default value for SH
2088   SORT        Override default value for SORT
2089   TAIL        Override default value for TAIL
2090   TAR         Override default value for TAR
2091   TEE         Override default value for TEE
2092   TOUCH       Override default value for TOUCH
2093   TR          Override default value for TR
2094   UNAME       Override default value for UNAME
2095   UNIQ        Override default value for UNIQ
2096   WC          Override default value for WC
2097   WHICH       Override default value for WHICH
2098   XARGS       Override default value for XARGS
2099   AWK         Override default value for AWK
2100   GREP        Override default value for GREP
2101   EGREP       Override default value for EGREP
2102   FGREP       Override default value for FGREP
2103   SED         Override default value for SED
2104   CYGPATH     Override default value for CYGPATH
2105   READLINK    Override default value for READLINK
2106   DF          Override default value for DF
2107   CPIO        Override default value for CPIO
2108   NICE        Override default value for NICE
2109   MAKE        Override default value for MAKE
2110   UNZIP       Override default value for UNZIP
2111   ZIP         Override default value for ZIP
2112   LDD         Override default value for LDD
2113   OTOOL       Override default value for OTOOL
2114   READELF     Override default value for READELF
2115   HG          Override default value for HG
2116   STAT        Override default value for STAT
2117   TIME        Override default value for TIME
2118   PATCH       Override default value for PATCH
2119   DSYMUTIL    Override default value for DSYMUTIL
2120   XATTR       Override default value for XATTR
2121   CODESIGN    Override default value for CODESIGN
2122   SETFILE     Override default value for SETFILE
2123   PKG_CONFIG  path to pkg-config utility
2124   JAVA        Override default value for JAVA
2125   JAVAC       Override default value for JAVAC
2126   JAVAH       Override default value for JAVAH
2127   JAR         Override default value for JAR
2128   JARSIGNER   Override default value for JARSIGNER
2129   CC          C compiler command
2130   CFLAGS      C compiler flags
2131   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
2132               nonstandard directory <lib dir>
2133   LIBS        libraries to pass to the linker, e.g. -l<library>
2134   CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
2135               you have headers in a nonstandard directory <include dir>
2136   CXX         C++ compiler command
2137   CXXFLAGS    C++ compiler flags
2138   CPP         C preprocessor
2139   CXXCPP      C++ preprocessor
2140   AS          Override default value for AS
2141   AR          Override default value for AR
2142   LIPO        Override default value for LIPO
2143   STRIP       Override default value for STRIP
2144   NM          Override default value for NM
2145   GNM         Override default value for GNM
2146   OBJCOPY     Override default value for OBJCOPY
2147   OBJDUMP     Override default value for OBJDUMP
2148   BUILD_CC    Override default value for BUILD_CC
2149   BUILD_CXX   Override default value for BUILD_CXX
2150   BUILD_NM    Override default value for BUILD_NM
2151   BUILD_AR    Override default value for BUILD_AR
2152   JTREGEXE    Override default value for JTREGEXE
2153   XMKMF       Path to xmkmf, Makefile generator for X Window System
2154   FREETYPE_CFLAGS
2155               C compiler flags for FREETYPE, overriding pkg-config
2156   FREETYPE_LIBS
2157               linker flags for FREETYPE, overriding pkg-config
2158   ALSA_CFLAGS C compiler flags for ALSA, overriding pkg-config
2159   ALSA_LIBS   linker flags for ALSA, overriding pkg-config
2160   LIBFFI_CFLAGS
2161               C compiler flags for LIBFFI, overriding pkg-config
2162   LIBFFI_LIBS linker flags for LIBFFI, overriding pkg-config
2163   PNG_CFLAGS  C compiler flags for PNG, overriding pkg-config
2164   PNG_LIBS    linker flags for PNG, overriding pkg-config
2165   LCMS_CFLAGS C compiler flags for LCMS, overriding pkg-config
2166   LCMS_LIBS   linker flags for LCMS, overriding pkg-config
2167   ICECC_CMD   Override default value for ICECC_CMD
2168   ICECC_CREATE_ENV
2169               Override default value for ICECC_CREATE_ENV
2170   ICECC_WRAPPER
2171               Override default value for ICECC_WRAPPER
2172   CCACHE      Override default value for CCACHE
2173 
2174 Use these variables to override the choices made by `configure' or to help
2175 it to find libraries and programs with nonstandard names/locations.
2176 
2177 Report bugs to <build-dev@openjdk.java.net>.
2178 OpenJDK home page: <http://openjdk.java.net>.
2179 _ACEOF
2180 ac_status=$?
2181 fi
2182 
2183 if test "$ac_init_help" = "recursive"; then
2184   # If there are subdirs, report their specific --help.
2185   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
2186     test -d "$ac_dir" ||
2187       { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } ||
2188       continue
2189     ac_builddir=.
2190 
2191 case "$ac_dir" in
2192 .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
2193 *)
2194   ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
2195   # A ".." for each directory in $ac_dir_suffix.
2196   ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
2197   case $ac_top_builddir_sub in
2198   "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
2199   *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
2200   esac ;;
2201 esac
2202 ac_abs_top_builddir=$ac_pwd
2203 ac_abs_builddir=$ac_pwd$ac_dir_suffix
2204 # for backward compatibility:
2205 ac_top_builddir=$ac_top_build_prefix
2206 
2207 case $srcdir in
2208   .)  # We are building in place.
2209     ac_srcdir=.
2210     ac_top_srcdir=$ac_top_builddir_sub
2211     ac_abs_top_srcdir=$ac_pwd ;;
2212   [\\/]* | ?:[\\/]* )  # Absolute name.
2213     ac_srcdir=$srcdir$ac_dir_suffix;
2214     ac_top_srcdir=$srcdir
2215     ac_abs_top_srcdir=$srcdir ;;
2216   *) # Relative name.
2217     ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
2218     ac_top_srcdir=$ac_top_build_prefix$srcdir
2219     ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
2220 esac
2221 ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
2222 
2223     cd "$ac_dir" || { ac_status=$?; continue; }
2224     # Check for guested configure.
2225     if test -f "$ac_srcdir/configure.gnu"; then
2226       echo &&
2227       $SHELL "$ac_srcdir/configure.gnu" --help=recursive
2228     elif test -f "$ac_srcdir/configure"; then
2229       echo &&
2230       $SHELL "$ac_srcdir/configure" --help=recursive
2231     else
2232       $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
2233     fi || ac_status=$?
2234     cd "$ac_pwd" || { ac_status=$?; break; }
2235   done
2236 fi
2237 
2238 test -n "$ac_init_help" && exit $ac_status
2239 if $ac_init_version; then
2240   cat <<\_ACEOF
2241 OpenJDK configure jdk9
2242 generated by GNU Autoconf 2.69
2243 
2244 Copyright (C) 2012 Free Software Foundation, Inc.
2245 This configure script is free software; the Free Software Foundation
2246 gives unlimited permission to copy, distribute and modify it.
2247 _ACEOF
2248   exit
2249 fi
2250 
2251 ## ------------------------ ##
2252 ## Autoconf initialization. ##
2253 ## ------------------------ ##
2254 
2255 # ac_fn_c_try_compile LINENO
2256 # --------------------------
2257 # Try to compile conftest.$ac_ext, and return whether this succeeded.
2258 ac_fn_c_try_compile ()
2259 {
2260   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2261   rm -f conftest.$ac_objext
2262   if { { ac_try="$ac_compile"
2263 case "(($ac_try" in
2264   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2265   *) ac_try_echo=$ac_try;;
2266 esac
2267 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2268 $as_echo "$ac_try_echo"; } >&5
2269   (eval "$ac_compile") 2>conftest.err
2270   ac_status=$?
2271   if test -s conftest.err; then
2272     grep -v '^ *+' conftest.err >conftest.er1
2273     cat conftest.er1 >&5
2274     mv -f conftest.er1 conftest.err
2275   fi
2276   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2277   test $ac_status = 0; } && {
2278          test -z "$ac_c_werror_flag" ||
2279          test ! -s conftest.err
2280        } && test -s conftest.$ac_objext; then :
2281   ac_retval=0
2282 else
2283   $as_echo "$as_me: failed program was:" >&5
2284 sed 's/^/| /' conftest.$ac_ext >&5
2285 
2286         ac_retval=1
2287 fi
2288   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2289   as_fn_set_status $ac_retval
2290 
2291 } # ac_fn_c_try_compile
2292 
2293 # ac_fn_cxx_try_compile LINENO
2294 # ----------------------------
2295 # Try to compile conftest.$ac_ext, and return whether this succeeded.
2296 ac_fn_cxx_try_compile ()
2297 {
2298   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2299   rm -f conftest.$ac_objext
2300   if { { ac_try="$ac_compile"
2301 case "(($ac_try" in
2302   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2303   *) ac_try_echo=$ac_try;;
2304 esac
2305 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2306 $as_echo "$ac_try_echo"; } >&5
2307   (eval "$ac_compile") 2>conftest.err
2308   ac_status=$?
2309   if test -s conftest.err; then
2310     grep -v '^ *+' conftest.err >conftest.er1
2311     cat conftest.er1 >&5
2312     mv -f conftest.er1 conftest.err
2313   fi
2314   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2315   test $ac_status = 0; } && {
2316          test -z "$ac_cxx_werror_flag" ||
2317          test ! -s conftest.err
2318        } && test -s conftest.$ac_objext; then :
2319   ac_retval=0
2320 else
2321   $as_echo "$as_me: failed program was:" >&5
2322 sed 's/^/| /' conftest.$ac_ext >&5
2323 
2324         ac_retval=1
2325 fi
2326   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2327   as_fn_set_status $ac_retval
2328 
2329 } # ac_fn_cxx_try_compile
2330 
2331 # ac_fn_c_try_cpp LINENO
2332 # ----------------------
2333 # Try to preprocess conftest.$ac_ext, and return whether this succeeded.
2334 ac_fn_c_try_cpp ()
2335 {
2336   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2337   if { { ac_try="$ac_cpp conftest.$ac_ext"
2338 case "(($ac_try" in
2339   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2340   *) ac_try_echo=$ac_try;;
2341 esac
2342 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2343 $as_echo "$ac_try_echo"; } >&5
2344   (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
2345   ac_status=$?
2346   if test -s conftest.err; then
2347     grep -v '^ *+' conftest.err >conftest.er1
2348     cat conftest.er1 >&5
2349     mv -f conftest.er1 conftest.err
2350   fi
2351   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2352   test $ac_status = 0; } > conftest.i && {
2353          test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
2354          test ! -s conftest.err
2355        }; then :
2356   ac_retval=0
2357 else
2358   $as_echo "$as_me: failed program was:" >&5
2359 sed 's/^/| /' conftest.$ac_ext >&5
2360 
2361     ac_retval=1
2362 fi
2363   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2364   as_fn_set_status $ac_retval
2365 
2366 } # ac_fn_c_try_cpp
2367 
2368 # ac_fn_cxx_try_cpp LINENO
2369 # ------------------------
2370 # Try to preprocess conftest.$ac_ext, and return whether this succeeded.
2371 ac_fn_cxx_try_cpp ()
2372 {
2373   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2374   if { { ac_try="$ac_cpp conftest.$ac_ext"
2375 case "(($ac_try" in
2376   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2377   *) ac_try_echo=$ac_try;;
2378 esac
2379 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2380 $as_echo "$ac_try_echo"; } >&5
2381   (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
2382   ac_status=$?
2383   if test -s conftest.err; then
2384     grep -v '^ *+' conftest.err >conftest.er1
2385     cat conftest.er1 >&5
2386     mv -f conftest.er1 conftest.err
2387   fi
2388   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2389   test $ac_status = 0; } > conftest.i && {
2390          test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
2391          test ! -s conftest.err
2392        }; then :
2393   ac_retval=0
2394 else
2395   $as_echo "$as_me: failed program was:" >&5
2396 sed 's/^/| /' conftest.$ac_ext >&5
2397 
2398     ac_retval=1
2399 fi
2400   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2401   as_fn_set_status $ac_retval
2402 
2403 } # ac_fn_cxx_try_cpp
2404 
2405 # ac_fn_c_try_link LINENO
2406 # -----------------------
2407 # Try to link conftest.$ac_ext, and return whether this succeeded.
2408 ac_fn_c_try_link ()
2409 {
2410   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2411   rm -f conftest.$ac_objext conftest$ac_exeext
2412   if { { ac_try="$ac_link"
2413 case "(($ac_try" in
2414   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2415   *) ac_try_echo=$ac_try;;
2416 esac
2417 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2418 $as_echo "$ac_try_echo"; } >&5
2419   (eval "$ac_link") 2>conftest.err
2420   ac_status=$?
2421   if test -s conftest.err; then
2422     grep -v '^ *+' conftest.err >conftest.er1
2423     cat conftest.er1 >&5
2424     mv -f conftest.er1 conftest.err
2425   fi
2426   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2427   test $ac_status = 0; } && {
2428          test -z "$ac_c_werror_flag" ||
2429          test ! -s conftest.err
2430        } && test -s conftest$ac_exeext && {
2431          test "$cross_compiling" = yes ||
2432          test -x conftest$ac_exeext
2433        }; then :
2434   ac_retval=0
2435 else
2436   $as_echo "$as_me: failed program was:" >&5
2437 sed 's/^/| /' conftest.$ac_ext >&5
2438 
2439         ac_retval=1
2440 fi
2441   # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
2442   # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
2443   # interfere with the next link command; also delete a directory that is
2444   # left behind by Apple's compiler.  We do this before executing the actions.
2445   rm -rf conftest.dSYM conftest_ipa8_conftest.oo
2446   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2447   as_fn_set_status $ac_retval
2448 
2449 } # ac_fn_c_try_link
2450 
2451 # ac_fn_cxx_check_header_mongrel LINENO HEADER VAR INCLUDES
2452 # ---------------------------------------------------------
2453 # Tests whether HEADER exists, giving a warning if it cannot be compiled using
2454 # the include files in INCLUDES and setting the cache variable VAR
2455 # accordingly.
2456 ac_fn_cxx_check_header_mongrel ()
2457 {
2458   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2459   if eval \${$3+:} false; then :
2460   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2461 $as_echo_n "checking for $2... " >&6; }
2462 if eval \${$3+:} false; then :
2463   $as_echo_n "(cached) " >&6
2464 fi
2465 eval ac_res=\$$3
2466                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2467 $as_echo "$ac_res" >&6; }
2468 else
2469   # Is the header compilable?
2470 { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
2471 $as_echo_n "checking $2 usability... " >&6; }
2472 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2473 /* end confdefs.h.  */
2474 $4
2475 #include <$2>
2476 _ACEOF
2477 if ac_fn_cxx_try_compile "$LINENO"; then :
2478   ac_header_compiler=yes
2479 else
2480   ac_header_compiler=no
2481 fi
2482 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2483 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
2484 $as_echo "$ac_header_compiler" >&6; }
2485 
2486 # Is the header present?
2487 { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
2488 $as_echo_n "checking $2 presence... " >&6; }
2489 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2490 /* end confdefs.h.  */
2491 #include <$2>
2492 _ACEOF
2493 if ac_fn_cxx_try_cpp "$LINENO"; then :
2494   ac_header_preproc=yes
2495 else
2496   ac_header_preproc=no
2497 fi
2498 rm -f conftest.err conftest.i conftest.$ac_ext
2499 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
2500 $as_echo "$ac_header_preproc" >&6; }
2501 
2502 # So?  What about this header?
2503 case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in #((
2504   yes:no: )
2505     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
2506 $as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
2507     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
2508 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
2509     ;;
2510   no:yes:* )
2511     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
2512 $as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
2513     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     check for missing prerequisite headers?" >&5
2514 $as_echo "$as_me: WARNING: $2:     check for missing prerequisite headers?" >&2;}
2515     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
2516 $as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
2517     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&5
2518 $as_echo "$as_me: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&2;}
2519     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
2520 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
2521 ( $as_echo "## ----------------------------------------- ##
2522 ## Report this to build-dev@openjdk.java.net ##
2523 ## ----------------------------------------- ##"
2524      ) | sed "s/^/$as_me: WARNING:     /" >&2
2525     ;;
2526 esac
2527   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2528 $as_echo_n "checking for $2... " >&6; }
2529 if eval \${$3+:} false; then :
2530   $as_echo_n "(cached) " >&6
2531 else
2532   eval "$3=\$ac_header_compiler"
2533 fi
2534 eval ac_res=\$$3
2535                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2536 $as_echo "$ac_res" >&6; }
2537 fi
2538   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2539 
2540 } # ac_fn_cxx_check_header_mongrel
2541 
2542 # ac_fn_cxx_try_run LINENO
2543 # ------------------------
2544 # Try to link conftest.$ac_ext, and return whether this succeeded. Assumes
2545 # that executables *can* be run.
2546 ac_fn_cxx_try_run ()
2547 {
2548   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2549   if { { ac_try="$ac_link"
2550 case "(($ac_try" in
2551   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2552   *) ac_try_echo=$ac_try;;
2553 esac
2554 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2555 $as_echo "$ac_try_echo"; } >&5
2556   (eval "$ac_link") 2>&5
2557   ac_status=$?
2558   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2559   test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'
2560   { { case "(($ac_try" in
2561   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2562   *) ac_try_echo=$ac_try;;
2563 esac
2564 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2565 $as_echo "$ac_try_echo"; } >&5
2566   (eval "$ac_try") 2>&5
2567   ac_status=$?
2568   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2569   test $ac_status = 0; }; }; then :
2570   ac_retval=0
2571 else
2572   $as_echo "$as_me: program exited with status $ac_status" >&5
2573        $as_echo "$as_me: failed program was:" >&5
2574 sed 's/^/| /' conftest.$ac_ext >&5
2575 
2576        ac_retval=$ac_status
2577 fi
2578   rm -rf conftest.dSYM conftest_ipa8_conftest.oo
2579   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2580   as_fn_set_status $ac_retval
2581 
2582 } # ac_fn_cxx_try_run
2583 
2584 # ac_fn_cxx_check_header_compile LINENO HEADER VAR INCLUDES
2585 # ---------------------------------------------------------
2586 # Tests whether HEADER exists and can be compiled using the include files in
2587 # INCLUDES, setting the cache variable VAR accordingly.
2588 ac_fn_cxx_check_header_compile ()
2589 {
2590   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
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 else
2596   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2597 /* end confdefs.h.  */
2598 $4
2599 #include <$2>
2600 _ACEOF
2601 if ac_fn_cxx_try_compile "$LINENO"; then :
2602   eval "$3=yes"
2603 else
2604   eval "$3=no"
2605 fi
2606 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2607 fi
2608 eval ac_res=\$$3
2609                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2610 $as_echo "$ac_res" >&6; }
2611   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2612 
2613 } # ac_fn_cxx_check_header_compile
2614 
2615 # ac_fn_cxx_compute_int LINENO EXPR VAR INCLUDES
2616 # ----------------------------------------------
2617 # Tries to find the compile-time value of EXPR in a program that includes
2618 # INCLUDES, setting VAR accordingly. Returns whether the value could be
2619 # computed
2620 ac_fn_cxx_compute_int ()
2621 {
2622   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2623   if test "$cross_compiling" = yes; then
2624     # Depending upon the size, compute the lo and hi bounds.
2625 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2626 /* end confdefs.h.  */
2627 $4
2628 int
2629 main ()
2630 {
2631 static int test_array [1 - 2 * !(($2) >= 0)];
2632 test_array [0] = 0;
2633 return test_array [0];
2634 
2635   ;
2636   return 0;
2637 }
2638 _ACEOF
2639 if ac_fn_cxx_try_compile "$LINENO"; then :
2640   ac_lo=0 ac_mid=0
2641   while :; do
2642     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2643 /* end confdefs.h.  */
2644 $4
2645 int
2646 main ()
2647 {
2648 static int test_array [1 - 2 * !(($2) <= $ac_mid)];
2649 test_array [0] = 0;
2650 return test_array [0];
2651 
2652   ;
2653   return 0;
2654 }
2655 _ACEOF
2656 if ac_fn_cxx_try_compile "$LINENO"; then :
2657   ac_hi=$ac_mid; break
2658 else
2659   as_fn_arith $ac_mid + 1 && ac_lo=$as_val
2660                         if test $ac_lo -le $ac_mid; then
2661                           ac_lo= ac_hi=
2662                           break
2663                         fi
2664                         as_fn_arith 2 '*' $ac_mid + 1 && ac_mid=$as_val
2665 fi
2666 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2667   done
2668 else
2669   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2670 /* end confdefs.h.  */
2671 $4
2672 int
2673 main ()
2674 {
2675 static int test_array [1 - 2 * !(($2) < 0)];
2676 test_array [0] = 0;
2677 return test_array [0];
2678 
2679   ;
2680   return 0;
2681 }
2682 _ACEOF
2683 if ac_fn_cxx_try_compile "$LINENO"; then :
2684   ac_hi=-1 ac_mid=-1
2685   while :; do
2686     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2687 /* end confdefs.h.  */
2688 $4
2689 int
2690 main ()
2691 {
2692 static int test_array [1 - 2 * !(($2) >= $ac_mid)];
2693 test_array [0] = 0;
2694 return test_array [0];
2695 
2696   ;
2697   return 0;
2698 }
2699 _ACEOF
2700 if ac_fn_cxx_try_compile "$LINENO"; then :
2701   ac_lo=$ac_mid; break
2702 else
2703   as_fn_arith '(' $ac_mid ')' - 1 && ac_hi=$as_val
2704                         if test $ac_mid -le $ac_hi; then
2705                           ac_lo= ac_hi=
2706                           break
2707                         fi
2708                         as_fn_arith 2 '*' $ac_mid && ac_mid=$as_val
2709 fi
2710 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2711   done
2712 else
2713   ac_lo= ac_hi=
2714 fi
2715 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2716 fi
2717 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2718 # Binary search between lo and hi bounds.
2719 while test "x$ac_lo" != "x$ac_hi"; do
2720   as_fn_arith '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo && ac_mid=$as_val
2721   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2722 /* end confdefs.h.  */
2723 $4
2724 int
2725 main ()
2726 {
2727 static int test_array [1 - 2 * !(($2) <= $ac_mid)];
2728 test_array [0] = 0;
2729 return test_array [0];
2730 
2731   ;
2732   return 0;
2733 }
2734 _ACEOF
2735 if ac_fn_cxx_try_compile "$LINENO"; then :
2736   ac_hi=$ac_mid
2737 else
2738   as_fn_arith '(' $ac_mid ')' + 1 && ac_lo=$as_val
2739 fi
2740 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2741 done
2742 case $ac_lo in #((
2743 ?*) eval "$3=\$ac_lo"; ac_retval=0 ;;
2744 '') ac_retval=1 ;;
2745 esac
2746   else
2747     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2748 /* end confdefs.h.  */
2749 $4
2750 static long int longval () { return $2; }
2751 static unsigned long int ulongval () { return $2; }
2752 #include <stdio.h>
2753 #include <stdlib.h>
2754 int
2755 main ()
2756 {
2757 
2758   FILE *f = fopen ("conftest.val", "w");
2759   if (! f)
2760     return 1;
2761   if (($2) < 0)
2762     {
2763       long int i = longval ();
2764       if (i != ($2))
2765         return 1;
2766       fprintf (f, "%ld", i);
2767     }
2768   else
2769     {
2770       unsigned long int i = ulongval ();
2771       if (i != ($2))
2772         return 1;
2773       fprintf (f, "%lu", i);
2774     }
2775   /* Do not output a trailing newline, as this causes \r\n confusion
2776      on some platforms.  */
2777   return ferror (f) || fclose (f) != 0;
2778 
2779   ;
2780   return 0;
2781 }
2782 _ACEOF
2783 if ac_fn_cxx_try_run "$LINENO"; then :
2784   echo >>conftest.val; read $3 <conftest.val; ac_retval=0
2785 else
2786   ac_retval=1
2787 fi
2788 rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
2789   conftest.$ac_objext conftest.beam conftest.$ac_ext
2790 rm -f conftest.val
2791 
2792   fi
2793   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2794   as_fn_set_status $ac_retval
2795 
2796 } # ac_fn_cxx_compute_int
2797 
2798 # ac_fn_cxx_try_link LINENO
2799 # -------------------------
2800 # Try to link conftest.$ac_ext, and return whether this succeeded.
2801 ac_fn_cxx_try_link ()
2802 {
2803   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2804   rm -f conftest.$ac_objext conftest$ac_exeext
2805   if { { ac_try="$ac_link"
2806 case "(($ac_try" in
2807   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2808   *) ac_try_echo=$ac_try;;
2809 esac
2810 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2811 $as_echo "$ac_try_echo"; } >&5
2812   (eval "$ac_link") 2>conftest.err
2813   ac_status=$?
2814   if test -s conftest.err; then
2815     grep -v '^ *+' conftest.err >conftest.er1
2816     cat conftest.er1 >&5
2817     mv -f conftest.er1 conftest.err
2818   fi
2819   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2820   test $ac_status = 0; } && {
2821          test -z "$ac_cxx_werror_flag" ||
2822          test ! -s conftest.err
2823        } && test -s conftest$ac_exeext && {
2824          test "$cross_compiling" = yes ||
2825          test -x conftest$ac_exeext
2826        }; then :
2827   ac_retval=0
2828 else
2829   $as_echo "$as_me: failed program was:" >&5
2830 sed 's/^/| /' conftest.$ac_ext >&5
2831 
2832         ac_retval=1
2833 fi
2834   # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
2835   # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
2836   # interfere with the next link command; also delete a directory that is
2837   # left behind by Apple's compiler.  We do this before executing the actions.
2838   rm -rf conftest.dSYM conftest_ipa8_conftest.oo
2839   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2840   as_fn_set_status $ac_retval
2841 
2842 } # ac_fn_cxx_try_link
2843 
2844 # ac_fn_cxx_check_func LINENO FUNC VAR
2845 # ------------------------------------
2846 # Tests whether FUNC exists, setting the cache variable VAR accordingly
2847 ac_fn_cxx_check_func ()
2848 {
2849   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2850   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2851 $as_echo_n "checking for $2... " >&6; }
2852 if eval \${$3+:} false; then :
2853   $as_echo_n "(cached) " >&6
2854 else
2855   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2856 /* end confdefs.h.  */
2857 /* Define $2 to an innocuous variant, in case <limits.h> declares $2.
2858    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
2859 #define $2 innocuous_$2
2860 
2861 /* System header to define __stub macros and hopefully few prototypes,
2862     which can conflict with char $2 (); below.
2863     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
2864     <limits.h> exists even on freestanding compilers.  */
2865 
2866 #ifdef __STDC__
2867 # include <limits.h>
2868 #else
2869 # include <assert.h>
2870 #endif
2871 
2872 #undef $2
2873 
2874 /* Override any GCC internal prototype to avoid an error.
2875    Use char because int might match the return type of a GCC
2876    builtin and then its argument prototype would still apply.  */
2877 #ifdef __cplusplus
2878 extern "C"
2879 #endif
2880 char $2 ();
2881 /* The GNU C library defines this for functions which it implements
2882     to always fail with ENOSYS.  Some functions are actually named
2883     something starting with __ and the normal name is an alias.  */
2884 #if defined __stub_$2 || defined __stub___$2
2885 choke me
2886 #endif
2887 
2888 int
2889 main ()
2890 {
2891 return $2 ();
2892   ;
2893   return 0;
2894 }
2895 _ACEOF
2896 if ac_fn_cxx_try_link "$LINENO"; then :
2897   eval "$3=yes"
2898 else
2899   eval "$3=no"
2900 fi
2901 rm -f core conftest.err conftest.$ac_objext \
2902     conftest$ac_exeext conftest.$ac_ext
2903 fi
2904 eval ac_res=\$$3
2905                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2906 $as_echo "$ac_res" >&6; }
2907   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2908 
2909 } # ac_fn_cxx_check_func
2910 
2911 # ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES
2912 # -------------------------------------------------------
2913 # Tests whether HEADER exists and can be compiled using the include files in
2914 # INCLUDES, setting the cache variable VAR accordingly.
2915 ac_fn_c_check_header_compile ()
2916 {
2917   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2918   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2919 $as_echo_n "checking for $2... " >&6; }
2920 if eval \${$3+:} false; then :
2921   $as_echo_n "(cached) " >&6
2922 else
2923   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2924 /* end confdefs.h.  */
2925 $4
2926 #include <$2>
2927 _ACEOF
2928 if ac_fn_c_try_compile "$LINENO"; then :
2929   eval "$3=yes"
2930 else
2931   eval "$3=no"
2932 fi
2933 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2934 fi
2935 eval ac_res=\$$3
2936                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2937 $as_echo "$ac_res" >&6; }
2938   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2939 
2940 } # ac_fn_c_check_header_compile
2941 cat >config.log <<_ACEOF
2942 This file contains any messages produced by compilers while
2943 running configure, to aid debugging if configure makes a mistake.
2944 
2945 It was created by OpenJDK $as_me jdk9, which was
2946 generated by GNU Autoconf 2.69.  Invocation command line was
2947 
2948   $ $0 $@
2949 
2950 _ACEOF
2951 exec 5>>config.log
2952 {
2953 cat <<_ASUNAME
2954 ## --------- ##
2955 ## Platform. ##
2956 ## --------- ##
2957 
2958 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
2959 uname -m = `(uname -m) 2>/dev/null || echo unknown`
2960 uname -r = `(uname -r) 2>/dev/null || echo unknown`
2961 uname -s = `(uname -s) 2>/dev/null || echo unknown`
2962 uname -v = `(uname -v) 2>/dev/null || echo unknown`
2963 
2964 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
2965 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
2966 
2967 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
2968 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
2969 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
2970 /usr/bin/hostinfo      = `(/usr/bin/hostinfo) 2>/dev/null      || echo unknown`
2971 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
2972 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
2973 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
2974 
2975 _ASUNAME
2976 
2977 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2978 for as_dir in $PATH
2979 do
2980   IFS=$as_save_IFS
2981   test -z "$as_dir" && as_dir=.
2982     $as_echo "PATH: $as_dir"
2983   done
2984 IFS=$as_save_IFS
2985 
2986 } >&5
2987 
2988 cat >&5 <<_ACEOF
2989 
2990 
2991 ## ----------- ##
2992 ## Core tests. ##
2993 ## ----------- ##
2994 
2995 _ACEOF
2996 
2997 
2998 # Keep a trace of the command line.
2999 # Strip out --no-create and --no-recursion so they do not pile up.
3000 # Strip out --silent because we don't want to record it for future runs.
3001 # Also quote any args containing shell meta-characters.
3002 # Make two passes to allow for proper duplicate-argument suppression.
3003 ac_configure_args=
3004 ac_configure_args0=
3005 ac_configure_args1=
3006 ac_must_keep_next=false
3007 for ac_pass in 1 2
3008 do
3009   for ac_arg
3010   do
3011     case $ac_arg in
3012     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
3013     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
3014     | -silent | --silent | --silen | --sile | --sil)
3015       continue ;;
3016     *\'*)
3017       ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
3018     esac
3019     case $ac_pass in
3020     1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;
3021     2)
3022       as_fn_append ac_configure_args1 " '$ac_arg'"
3023       if test $ac_must_keep_next = true; then
3024         ac_must_keep_next=false # Got value, back to normal.
3025       else
3026         case $ac_arg in
3027           *=* | --config-cache | -C | -disable-* | --disable-* \
3028           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
3029           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
3030           | -with-* | --with-* | -without-* | --without-* | --x)
3031             case "$ac_configure_args0 " in
3032               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
3033             esac
3034             ;;
3035           -* ) ac_must_keep_next=true ;;
3036         esac
3037       fi
3038       as_fn_append ac_configure_args " '$ac_arg'"
3039       ;;
3040     esac
3041   done
3042 done
3043 { ac_configure_args0=; unset ac_configure_args0;}
3044 { ac_configure_args1=; unset ac_configure_args1;}
3045 
3046 # When interrupted or exit'd, cleanup temporary files, and complete
3047 # config.log.  We remove comments because anyway the quotes in there
3048 # would cause problems or look ugly.
3049 # WARNING: Use '\'' to represent an apostrophe within the trap.
3050 # WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.
3051 trap 'exit_status=$?
3052   # Save into config.log some information that might help in debugging.
3053   {
3054     echo
3055 
3056     $as_echo "## ---------------- ##
3057 ## Cache variables. ##
3058 ## ---------------- ##"
3059     echo
3060     # The following way of writing the cache mishandles newlines in values,
3061 (
3062   for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do
3063     eval ac_val=\$$ac_var
3064     case $ac_val in #(
3065     *${as_nl}*)
3066       case $ac_var in #(
3067       *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
3068 $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
3069       esac
3070       case $ac_var in #(
3071       _ | IFS | as_nl) ;; #(
3072       BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
3073       *) { eval $ac_var=; unset $ac_var;} ;;
3074       esac ;;
3075     esac
3076   done
3077   (set) 2>&1 |
3078     case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #(
3079     *${as_nl}ac_space=\ *)
3080       sed -n \
3081         "s/'\''/'\''\\\\'\'''\''/g;
3082           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p"
3083       ;; #(
3084     *)
3085       sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
3086       ;;
3087     esac |
3088     sort
3089 )
3090     echo
3091 
3092     $as_echo "## ----------------- ##
3093 ## Output variables. ##
3094 ## ----------------- ##"
3095     echo
3096     for ac_var in $ac_subst_vars
3097     do
3098       eval ac_val=\$$ac_var
3099       case $ac_val in
3100       *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
3101       esac
3102       $as_echo "$ac_var='\''$ac_val'\''"
3103     done | sort
3104     echo
3105 
3106     if test -n "$ac_subst_files"; then
3107       $as_echo "## ------------------- ##
3108 ## File substitutions. ##
3109 ## ------------------- ##"
3110       echo
3111       for ac_var in $ac_subst_files
3112       do
3113         eval ac_val=\$$ac_var
3114         case $ac_val in
3115         *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
3116         esac
3117         $as_echo "$ac_var='\''$ac_val'\''"
3118       done | sort
3119       echo
3120     fi
3121 
3122     if test -s confdefs.h; then
3123       $as_echo "## ----------- ##
3124 ## confdefs.h. ##
3125 ## ----------- ##"
3126       echo
3127       cat confdefs.h
3128       echo
3129     fi
3130     test "$ac_signal" != 0 &&
3131       $as_echo "$as_me: caught signal $ac_signal"
3132     $as_echo "$as_me: exit $exit_status"
3133   } >&5
3134   rm -f core *.core core.conftest.* &&
3135     rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
3136     exit $exit_status
3137 ' 0
3138 for ac_signal in 1 2 13 15; do
3139   trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal
3140 done
3141 ac_signal=0
3142 
3143 # confdefs.h avoids OS command line length limits that DEFS can exceed.
3144 rm -f -r conftest* confdefs.h
3145 
3146 $as_echo "/* confdefs.h */" > confdefs.h
3147 
3148 # Predefined preprocessor variables.
3149 
3150 cat >>confdefs.h <<_ACEOF
3151 #define PACKAGE_NAME "$PACKAGE_NAME"
3152 _ACEOF
3153 
3154 cat >>confdefs.h <<_ACEOF
3155 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
3156 _ACEOF
3157 
3158 cat >>confdefs.h <<_ACEOF
3159 #define PACKAGE_VERSION "$PACKAGE_VERSION"
3160 _ACEOF
3161 
3162 cat >>confdefs.h <<_ACEOF
3163 #define PACKAGE_STRING "$PACKAGE_STRING"
3164 _ACEOF
3165 
3166 cat >>confdefs.h <<_ACEOF
3167 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
3168 _ACEOF
3169 
3170 cat >>confdefs.h <<_ACEOF
3171 #define PACKAGE_URL "$PACKAGE_URL"
3172 _ACEOF
3173 
3174 
3175 # Let the site file select an alternate cache file if it wants to.
3176 # Prefer an explicitly selected file to automatically selected ones.
3177 ac_site_file1=NONE
3178 ac_site_file2=NONE
3179 if test -n "$CONFIG_SITE"; then
3180   # We do not want a PATH search for config.site.
3181   case $CONFIG_SITE in #((
3182     -*)  ac_site_file1=./$CONFIG_SITE;;
3183     */*) ac_site_file1=$CONFIG_SITE;;
3184     *)   ac_site_file1=./$CONFIG_SITE;;
3185   esac
3186 elif test "x$prefix" != xNONE; then
3187   ac_site_file1=$prefix/share/config.site
3188   ac_site_file2=$prefix/etc/config.site
3189 else
3190   ac_site_file1=$ac_default_prefix/share/config.site
3191   ac_site_file2=$ac_default_prefix/etc/config.site
3192 fi
3193 for ac_site_file in "$ac_site_file1" "$ac_site_file2"
3194 do
3195   test "x$ac_site_file" = xNONE && continue
3196   if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then
3197     { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
3198 $as_echo "$as_me: loading site script $ac_site_file" >&6;}
3199     sed 's/^/| /' "$ac_site_file" >&5
3200     . "$ac_site_file" \
3201       || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3202 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3203 as_fn_error $? "failed to load site script $ac_site_file
3204 See \`config.log' for more details" "$LINENO" 5; }
3205   fi
3206 done
3207 
3208 if test -r "$cache_file"; then
3209   # Some versions of bash will fail to source /dev/null (special files
3210   # actually), so we avoid doing that.  DJGPP emulates it as a regular file.
3211   if test /dev/null != "$cache_file" && test -f "$cache_file"; then
3212     { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
3213 $as_echo "$as_me: loading cache $cache_file" >&6;}
3214     case $cache_file in
3215       [\\/]* | ?:[\\/]* ) . "$cache_file";;
3216       *)                      . "./$cache_file";;
3217     esac
3218   fi
3219 else
3220   { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
3221 $as_echo "$as_me: creating cache $cache_file" >&6;}
3222   >$cache_file
3223 fi
3224 
3225 # Check that the precious variables saved in the cache have kept the same
3226 # value.
3227 ac_cache_corrupted=false
3228 for ac_var in $ac_precious_vars; do
3229   eval ac_old_set=\$ac_cv_env_${ac_var}_set
3230   eval ac_new_set=\$ac_env_${ac_var}_set
3231   eval ac_old_val=\$ac_cv_env_${ac_var}_value
3232   eval ac_new_val=\$ac_env_${ac_var}_value
3233   case $ac_old_set,$ac_new_set in
3234     set,)
3235       { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
3236 $as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
3237       ac_cache_corrupted=: ;;
3238     ,set)
3239       { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5
3240 $as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
3241       ac_cache_corrupted=: ;;
3242     ,);;
3243     *)
3244       if test "x$ac_old_val" != "x$ac_new_val"; then
3245         # differences in whitespace do not lead to failure.
3246         ac_old_val_w=`echo x $ac_old_val`
3247         ac_new_val_w=`echo x $ac_new_val`
3248         if test "$ac_old_val_w" != "$ac_new_val_w"; then
3249           { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5
3250 $as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
3251           ac_cache_corrupted=:
3252         else
3253           { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
3254 $as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
3255           eval $ac_var=\$ac_old_val
3256         fi
3257         { $as_echo "$as_me:${as_lineno-$LINENO}:   former value:  \`$ac_old_val'" >&5
3258 $as_echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
3259         { $as_echo "$as_me:${as_lineno-$LINENO}:   current value: \`$ac_new_val'" >&5
3260 $as_echo "$as_me:   current value: \`$ac_new_val'" >&2;}
3261       fi;;
3262   esac
3263   # Pass precious variables to config.status.
3264   if test "$ac_new_set" = set; then
3265     case $ac_new_val in
3266     *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
3267     *) ac_arg=$ac_var=$ac_new_val ;;
3268     esac
3269     case " $ac_configure_args " in
3270       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
3271       *) as_fn_append ac_configure_args " '$ac_arg'" ;;
3272     esac
3273   fi
3274 done
3275 if $ac_cache_corrupted; then
3276   { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3277 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3278   { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
3279 $as_echo "$as_me: error: changes in the environment can compromise the build" >&2;}
3280   as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5
3281 fi
3282 ## -------------------- ##
3283 ## Main body of script. ##
3284 ## -------------------- ##
3285 
3286 ac_ext=c
3287 ac_cpp='$CPP $CPPFLAGS'
3288 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3289 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3290 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3291 
3292 
3293 
3294 ac_aux_dir=
3295 for ac_dir in $TOPDIR/common/autoconf/build-aux "$srcdir"/$TOPDIR/common/autoconf/build-aux; do
3296   if test -f "$ac_dir/install-sh"; then
3297     ac_aux_dir=$ac_dir
3298     ac_install_sh="$ac_aux_dir/install-sh -c"
3299     break
3300   elif test -f "$ac_dir/install.sh"; then
3301     ac_aux_dir=$ac_dir
3302     ac_install_sh="$ac_aux_dir/install.sh -c"
3303     break
3304   elif test -f "$ac_dir/shtool"; then
3305     ac_aux_dir=$ac_dir
3306     ac_install_sh="$ac_aux_dir/shtool install -c"
3307     break
3308   fi
3309 done
3310 if test -z "$ac_aux_dir"; then
3311   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
3312 fi
3313 
3314 # These three variables are undocumented and unsupported,
3315 # and are intended to be withdrawn in a future Autoconf release.
3316 # They can cause serious problems if a builder's source tree is in a directory
3317 # whose full name contains unusual characters.
3318 ac_config_guess="$SHELL $ac_aux_dir/config.guess"  # Please don't use this var.
3319 ac_config_sub="$SHELL $ac_aux_dir/config.sub"  # Please don't use this var.
3320 ac_configure="$SHELL $ac_aux_dir/configure"  # Please don't use this var.
3321 
3322 
3323 # pkg.m4 - Macros to locate and utilise pkg-config.            -*- Autoconf -*-
3324 
3325 #
3326 # Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
3327 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3328 #
3329 # This code is free software; you can redistribute it and/or modify it
3330 # under the terms of the GNU General Public License version 2 only, as
3331 # published by the Free Software Foundation.  Oracle designates this
3332 # particular file as subject to the "Classpath" exception as provided
3333 # by Oracle in the LICENSE file that accompanied this code.
3334 #
3335 # This code is distributed in the hope that it will be useful, but WITHOUT
3336 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3337 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3338 # version 2 for more details (a copy is included in the LICENSE file that
3339 # accompanied this code).
3340 #
3341 # You should have received a copy of the GNU General Public License version
3342 # 2 along with this work; if not, write to the Free Software Foundation,
3343 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3344 #
3345 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3346 # or visit www.oracle.com if you need additional information or have any
3347 # questions.
3348 #
3349 
3350 #
3351 # Copyright © 2004 Scott James Remnant <scott@netsplit.com>.
3352 #
3353 # This program is free software; you can redistribute it and/or modify
3354 # it under the terms of the GNU General Public License as published by
3355 # the Free Software Foundation; either version 2 of the License, or
3356 # (at your option) any later version.
3357 #
3358 # This program is distributed in the hope that it will be useful, but
3359 # WITHOUT ANY WARRANTY; without even the implied warranty of
3360 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
3361 # General Public License for more details.
3362 #
3363 # You should have received a copy of the GNU General Public License
3364 # along with this program; if not, write to the Free Software
3365 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
3366 #
3367 # As a special exception to the GNU General Public License, if you
3368 # distribute this file as part of a program that contains a
3369 # configuration script generated by Autoconf, you may include it under
3370 # the same distribution terms that you use for the rest of that program.
3371 
3372 # PKG_PROG_PKG_CONFIG([MIN-VERSION])
3373 # ----------------------------------
3374 # PKG_PROG_PKG_CONFIG
3375 
3376 # PKG_CHECK_EXISTS(MODULES, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
3377 #
3378 # Check to see whether a particular set of modules exists.  Similar
3379 # to PKG_CHECK_MODULES(), but does not set variables or print errors.
3380 #
3381 #
3382 # Similar to PKG_CHECK_MODULES, make sure that the first instance of
3383 # this or PKG_CHECK_MODULES is called, or make sure to call
3384 # PKG_CHECK_EXISTS manually
3385 # --------------------------------------------------------------
3386 
3387 
3388 
3389 # _PKG_CONFIG([VARIABLE], [COMMAND], [MODULES])
3390 # ---------------------------------------------
3391 # _PKG_CONFIG
3392 
3393 # _PKG_SHORT_ERRORS_SUPPORTED
3394 # -----------------------------
3395 # _PKG_SHORT_ERRORS_SUPPORTED
3396 
3397 
3398 # PKG_CHECK_MODULES(VARIABLE-PREFIX, MODULES, [ACTION-IF-FOUND],
3399 # [ACTION-IF-NOT-FOUND])
3400 #
3401 #
3402 # Note that if there is a possibility the first call to
3403 # PKG_CHECK_MODULES might not happen, you should be sure to include an
3404 # explicit call to PKG_PROG_PKG_CONFIG in your configure.ac
3405 #
3406 #
3407 # --------------------------------------------------------------
3408 # PKG_CHECK_MODULES
3409 
3410 
3411 # Include these first...
3412 #
3413 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
3414 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3415 #
3416 # This code is free software; you can redistribute it and/or modify it
3417 # under the terms of the GNU General Public License version 2 only, as
3418 # published by the Free Software Foundation.  Oracle designates this
3419 # particular file as subject to the "Classpath" exception as provided
3420 # by Oracle in the LICENSE file that accompanied this code.
3421 #
3422 # This code is distributed in the hope that it will be useful, but WITHOUT
3423 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3424 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3425 # version 2 for more details (a copy is included in the LICENSE file that
3426 # accompanied this code).
3427 #
3428 # You should have received a copy of the GNU General Public License version
3429 # 2 along with this work; if not, write to the Free Software Foundation,
3430 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3431 #
3432 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3433 # or visit www.oracle.com if you need additional information or have any
3434 # questions.
3435 #
3436 
3437 # Test if $1 is a valid argument to $3 (often is $JAVA passed as $3)
3438 # If so, then append $1 to $2 \
3439 # Also set JVM_ARG_OK to true/false depending on outcome.
3440 
3441 
3442 # Appends a string to a path variable, only adding the : when needed.
3443 
3444 
3445 # Prepends a string to a path variable, only adding the : when needed.
3446 
3447 
3448 # This will make sure the given variable points to a full and proper
3449 # path. This means:
3450 # 1) There will be no spaces in the path. On unix platforms,
3451 #    spaces in the path will result in an error. On Windows,
3452 #    the path will be rewritten using short-style to be space-free.
3453 # 2) The path will be absolute, and it will be in unix-style (on
3454 #     cygwin).
3455 # $1: The name of the variable to fix
3456 
3457 
3458 # This will make sure the given variable points to a executable
3459 # with a full and proper path. This means:
3460 # 1) There will be no spaces in the path. On unix platforms,
3461 #    spaces in the path will result in an error. On Windows,
3462 #    the path will be rewritten using short-style to be space-free.
3463 # 2) The path will be absolute, and it will be in unix-style (on
3464 #     cygwin).
3465 # Any arguments given to the executable is preserved.
3466 # If the input variable does not have a directory specification, then
3467 # it need to be in the PATH.
3468 # $1: The name of the variable to fix
3469 
3470 
3471 
3472 
3473 # Register a --with argument but mark it as deprecated
3474 # $1: The name of the with argument to deprecate, not including --with-
3475 
3476 
3477 # Register a --enable argument but mark it as deprecated
3478 # $1: The name of the with argument to deprecate, not including --enable-
3479 # $2: The name of the argument to deprecate, in shell variable style (i.e. with _ instead of -)

3480 
3481 
3482 
3483 
3484 # Test that variable $1 denoting a program is not empty. If empty, exit with an error.
3485 # $1: variable to check
3486 
3487 
3488 # Check that there are no unprocessed overridden variables left.
3489 # If so, they are an incorrect argument and we will exit with an error.
3490 
3491 
3492 # Setup a tool for the given variable. If correctly specified by the user,
3493 # use that value, otherwise search for the tool using the supplied code snippet.
3494 # $1: variable to set
3495 # $2: code snippet to call to look for the tool
3496 # $3: code snippet to call if variable was used to find tool
3497 
3498 
3499 # Call BASIC_SETUP_TOOL with AC_PATH_PROGS to locate the tool
3500 # $1: variable to set
3501 # $2: executable name (or list of names) to look for
3502 
3503 
3504 # Call BASIC_SETUP_TOOL with AC_CHECK_TOOLS to locate the tool
3505 # $1: variable to set
3506 # $2: executable name (or list of names) to look for
3507 
3508 
3509 # Like BASIC_PATH_PROGS but fails if no tool was found.
3510 # $1: variable to set
3511 # $2: executable name (or list of names) to look for
3512 
3513 
3514 # Like BASIC_SETUP_TOOL but fails if no tool was found.
3515 # $1: variable to set
3516 # $2: autoconf macro to call to look for the special tool
3517 
3518 
3519 # Setup the most fundamental tools that relies on not much else to set up,
3520 # but is used by much of the early bootstrap code.
3521 
3522 
3523 # Setup basic configuration paths, and platform-specific stuff related to PATHs.
3524 
3525 
3526 # Evaluates platform specific overrides for devkit variables.
3527 # $1: Name of variable
3528 
3529 
3530 
3531 
3532 
3533 
3534 #%%% Simple tools %%%
3535 
3536 # Check if we have found a usable version of make
3537 # $1: the path to a potential make binary (or empty)
3538 # $2: the description on how we found this
3539 
3540 
3541 
3542 
3543 # Goes looking for a usable version of GNU make.
3544 
3545 
3546 
3547 
3548 
3549 
3550 # Check if build directory is on local disk. If not possible to determine,
3551 # we prefer to claim it's local.
3552 # Argument 1: directory to test
3553 # Argument 2: what to do if it is on local disk
3554 # Argument 3: what to do otherwise (remote disk or failure)
3555 
3556 
3557 # Check that source files have basic read permissions set. This might
3558 # not be the case in cygwin in certain conditions.
3559 
3560 
3561 
3562 
3563 # Check for support for specific options in bash
3564 
3565 
3566 # Code to run after AC_OUTPUT
3567 
3568 
3569 #
3570 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
3571 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3572 #
3573 # This code is free software; you can redistribute it and/or modify it
3574 # under the terms of the GNU General Public License version 2 only, as
3575 # published by the Free Software Foundation.  Oracle designates this
3576 # particular file as subject to the "Classpath" exception as provided
3577 # by Oracle in the LICENSE file that accompanied this code.
3578 #
3579 # This code is distributed in the hope that it will be useful, but WITHOUT
3580 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3581 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3582 # version 2 for more details (a copy is included in the LICENSE file that
3583 # accompanied this code).
3584 #
3585 # You should have received a copy of the GNU General Public License version
3586 # 2 along with this work; if not, write to the Free Software Foundation,
3587 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3588 #
3589 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3590 # or visit www.oracle.com if you need additional information or have any
3591 # questions.
3592 #
3593 
3594 
3595 
3596 
3597 
3598 # Helper function which possibly converts a path using DOS-style short mode.
3599 # If so, the updated path is stored in $new_path.
3600 # $1: The path to check
3601 
3602 
3603 # Helper function which possibly converts a path using DOS-style short mode.
3604 # If so, the updated path is stored in $new_path.
3605 # $1: The path to check
3606 
3607 
3608 # FIXME: The BASIC_FIXUP_*_CYGWIN/MSYS is most likely too convoluted
3609 # and could probably be heavily simplified. However, all changes in this
3610 # area tend to need lot of testing in different scenarios, and in lack of
3611 # proper unit testing, cleaning this up has not been deemed worth the effort
3612 # at the moment.
3613 
3614 
3615 
3616 
3617 
3618 
3619 
3620 
3621 
3622 # Setup basic configuration paths, and platform-specific stuff related to PATHs.
3623 
3624 
3625 
3626 
3627 # ... then the rest
3628 #
3629 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
3630 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3631 #
3632 # This code is free software; you can redistribute it and/or modify it
3633 # under the terms of the GNU General Public License version 2 only, as
3634 # published by the Free Software Foundation.  Oracle designates this
3635 # particular file as subject to the "Classpath" exception as provided
3636 # by Oracle in the LICENSE file that accompanied this code.
3637 #
3638 # This code is distributed in the hope that it will be useful, but WITHOUT
3639 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3640 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3641 # version 2 for more details (a copy is included in the LICENSE file that
3642 # accompanied this code).
3643 #
3644 # You should have received a copy of the GNU General Public License version
3645 # 2 along with this work; if not, write to the Free Software Foundation,
3646 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3647 #
3648 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3649 # or visit www.oracle.com if you need additional information or have any
3650 # questions.
3651 #
3652 
3653 ########################################################################
3654 # This file handles detection of the Boot JDK. The Boot JDK detection
3655 # process has been developed as a response to solve a complex real-world
3656 # problem. Initially, it was simple, but it has grown as platform after
3657 # platform, idiosyncracy after idiosyncracy has been supported.
3658 #
3659 # The basic idea is this:
3660 # 1) You need an acceptable *) JDK to use as a Boot JDK
3661 # 2) There are several ways to locate a JDK, that are mostly platform
3662 #    dependent **)
3663 # 3) You can have multiple JDKs installed
3664 # 4) If possible, configure should try to dig out an acceptable JDK
3665 #    automatically, without having to resort to command-line options
3666 #
3667 # *)  acceptable means e.g. JDK7 for building JDK8, a complete JDK (with
3668 #     javac) and not a JRE, etc.
3669 #
3670 # **) On Windows we typically use a well-known path.
3671 #     On MacOSX we typically use the tool java_home.
3672 #     On Linux we typically find javac in the $PATH, and then follow a
3673 #     chain of symlinks that often ends up in a real JDK.
3674 #
3675 # This leads to the code where we check in different ways to locate a
3676 # JDK, and if one is found, check if it is acceptable. If not, we print
3677 # our reasons for rejecting it (useful when debugging non-working
3678 # configure situations) and continue checking the next one.
3679 ########################################################################
3680 
3681 # Execute the check given as argument, and verify the result
3682 # If the Boot JDK was previously found, do nothing
3683 # $1 A command line (typically autoconf macro) to execute
3684 
3685 
3686 # Test: Is bootjdk explicitely set by command line arguments?
3687 
3688 
3689 # Test: Is $JAVA_HOME set?
3690 
3691 
3692 # Test: Is there a java or javac in the PATH, which is a symlink to the JDK?
3693 
3694 
3695 # Test: Is there a /usr/libexec/java_home? (Typically on MacOSX)
3696 # $1: Argument to the java_home binary (optional)
3697 
3698 
3699 # Test: On MacOS X, can we find a boot jdk using /usr/libexec/java_home?
3700 
3701 
3702 # Look for a jdk in the given path. If there are multiple, try to select the newest.
3703 # If found, set BOOT_JDK and BOOT_JDK_FOUND.
3704 # $1 = Path to directory containing jdk installations.
3705 # $2 = String to append to the found JDK directory to get the proper JDK home
3706 
3707 
3708 # Call BOOTJDK_FIND_BEST_JDK_IN_DIRECTORY, but use the given
3709 # environmental variable as base for where to look.
3710 # $1 Name of an environmal variable, assumed to point to the Program Files directory.
3711 
3712 
3713 # Test: Is there a JDK installed in default, well-known locations?
3714 
3715 
3716 # Check that a command-line tool in the Boot JDK is correct
3717 # $1 = name of variable to assign
3718 # $2 = name of binary
3719 
3720 
3721 ###############################################################################
3722 #
3723 # We need a Boot JDK to bootstrap the build.
3724 #
3725 
3726 
3727 
3728 
3729 
3730 #
3731 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
3732 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3733 #
3734 # This code is free software; you can redistribute it and/or modify it
3735 # under the terms of the GNU General Public License version 2 only, as
3736 # published by the Free Software Foundation.  Oracle designates this
3737 # particular file as subject to the "Classpath" exception as provided
3738 # by Oracle in the LICENSE file that accompanied this code.
3739 #
3740 # This code is distributed in the hope that it will be useful, but WITHOUT
3741 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3742 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3743 # version 2 for more details (a copy is included in the LICENSE file that
3744 # accompanied this code).
3745 #
3746 # You should have received a copy of the GNU General Public License version
3747 # 2 along with this work; if not, write to the Free Software Foundation,
3748 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3749 #
3750 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3751 # or visit www.oracle.com if you need additional information or have any
3752 # questions.
3753 #
3754 
3755 
3756 
3757 
3758 
3759 
3760 
3761 
3762 
3763 
3764 
3765 
3766 
3767 
3768 
3769 ################################################################################
3770 #
3771 # Optionally enable distributed compilation of native code using icecc/icecream
3772 #
3773 
3774 
3775 
3776 
3777 
3778 
3779 
3780 #
3781 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
3782 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3783 #
3784 # This code is free software; you can redistribute it and/or modify it
3785 # under the terms of the GNU General Public License version 2 only, as
3786 # published by the Free Software Foundation.  Oracle designates this
3787 # particular file as subject to the "Classpath" exception as provided
3788 # by Oracle in the LICENSE file that accompanied this code.
3789 #
3790 # This code is distributed in the hope that it will be useful, but WITHOUT
3791 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3792 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3793 # version 2 for more details (a copy is included in the LICENSE file that
3794 # accompanied this code).
3795 #
3796 # You should have received a copy of the GNU General Public License version
3797 # 2 along with this work; if not, write to the Free Software Foundation,
3798 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3799 #
3800 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3801 # or visit www.oracle.com if you need additional information or have any
3802 # questions.
3803 #
3804 
3805 # Reset the global CFLAGS/LDFLAGS variables and initialize them with the
3806 # corresponding configure arguments instead
3807 
3808 
3809 # Setup the sysroot flags and add them to global CFLAGS and LDFLAGS so
3810 # that configure can use them while detecting compilers.
3811 # TOOLCHAIN_TYPE is available here.
3812 # Param 1 - Optional prefix to all variables. (e.g BUILD_)
3813 
3814 
3815 
3816 
3817 
3818 
3819 # Documentation on common flags used for solstudio in HIGHEST.
3820 #
3821 # WARNING: Use of OPTIMIZATION_LEVEL=HIGHEST in your Makefile needs to be
3822 #          done with care, there are some assumptions below that need to
3823 #          be understood about the use of pointers, and IEEE behavior.
3824 #
3825 # -fns: Use non-standard floating point mode (not IEEE 754)
3826 # -fsimple: Do some simplification of floating point arithmetic (not IEEE 754)
3827 # -fsingle: Use single precision floating point with 'float'
3828 # -xalias_level=basic: Assume memory references via basic pointer types do not alias
3829 #   (Source with excessing pointer casting and data access with mixed
3830 #    pointer types are not recommended)
3831 # -xbuiltin=%all: Use intrinsic or inline versions for math/std functions
3832 #   (If you expect perfect errno behavior, do not use this)
3833 # -xdepend: Loop data dependency optimizations (need -xO3 or higher)
3834 # -xrestrict: Pointer parameters to functions do not overlap
3835 #   (Similar to -xalias_level=basic usage, but less obvious sometimes.
3836 #    If you pass in multiple pointers to the same data, do not use this)
3837 # -xlibmil: Inline some library routines
3838 #   (If you expect perfect errno behavior, do not use this)
3839 # -xlibmopt: Use optimized math routines (CURRENTLY DISABLED)
3840 #   (If you expect perfect errno behavior, do not use this)
3841 #  Can cause undefined external on Solaris 8 X86 on __sincos, removing for now
3842 
3843     # FIXME: this will never happen since sparc != sparcv9, ie 32 bit, which we don't build anymore.
3844     # Bug?
3845     #if test "x$OPENJDK_TARGET_CPU" = xsparc; then
3846     #  CFLAGS_JDK="${CFLAGS_JDK} -xmemalign=4s"
3847     #  CXXFLAGS_JDK="${CXXFLAGS_JDK} -xmemalign=4s"
3848     #fi
3849 
3850 
3851 
3852 
3853 
3854 # FLAGS_COMPILER_CHECK_ARGUMENTS([ARGUMENT], [RUN-IF-TRUE],
3855 #                                   [RUN-IF-FALSE])
3856 # ------------------------------------------------------------
3857 # Check that the c and c++ compilers support an argument
3858 
3859 
3860 # FLAGS_LINKER_CHECK_ARGUMENTS([ARGUMENT], [RUN-IF-TRUE],
3861 #                                    [RUN-IF-FALSE])
3862 # ------------------------------------------------------------
3863 # Check that the linker support an argument
3864 
3865 
3866 
3867 
3868 #
3869 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
3870 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3871 #
3872 # This code is free software; you can redistribute it and/or modify it
3873 # under the terms of the GNU General Public License version 2 only, as
3874 # published by the Free Software Foundation.  Oracle designates this
3875 # particular file as subject to the "Classpath" exception as provided
3876 # by Oracle in the LICENSE file that accompanied this code.
3877 #
3878 # This code is distributed in the hope that it will be useful, but WITHOUT
3879 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3880 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3881 # version 2 for more details (a copy is included in the LICENSE file that
3882 # accompanied this code).
3883 #
3884 # You should have received a copy of the GNU General Public License version
3885 # 2 along with this work; if not, write to the Free Software Foundation,
3886 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3887 #
3888 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3889 # or visit www.oracle.com if you need additional information or have any
3890 # questions.
3891 #
3892 
3893 
3894 
3895 
3896 
3897 cygwin_help() {
3898   case $1 in
3899     unzip)
3900       PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P unzip )"
3901       HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
3902       ;;
3903     zip)
3904       PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P zip )"
3905       HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
3906       ;;
3907     make)
3908       PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P make )"
3909       HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
3910       ;;
3911     freetype)
3912       HELP_MSG="
3913 The freetype library can now be build during the configure process.
3914 Download the freetype sources and unpack them into an arbitrary directory:
3915 
3916 wget http://download.savannah.gnu.org/releases/freetype/freetype-2.5.3.tar.gz
3917 tar -xzf freetype-2.5.3.tar.gz
3918 
3919 Then run configure with '--with-freetype-src=<freetype_src>'. This will
3920 automatically build the freetype library into '<freetype_src>/lib64' for 64-bit
3921 builds or into '<freetype_src>/lib32' for 32-bit builds.
3922 Afterwards you can always use '--with-freetype-include=<freetype_src>/include'
3923 and '--with-freetype-lib=<freetype_src>/lib32|64' for other builds."
3924       ;;
3925   esac
3926 }
3927 
3928 msys_help() {
3929   PKGHANDLER_COMMAND=""
3930 }
3931 
3932 apt_help() {
3933   case $1 in
3934     reduced)
3935       PKGHANDLER_COMMAND="sudo apt-get install gcc-multilib g++-multilib" ;;
3936     devkit)
3937       PKGHANDLER_COMMAND="sudo apt-get install build-essential" ;;
3938     openjdk)
3939       PKGHANDLER_COMMAND="sudo apt-get install openjdk-7-jdk" ;;
3940     alsa)
3941       PKGHANDLER_COMMAND="sudo apt-get install libasound2-dev" ;;
3942     cups)
3943       PKGHANDLER_COMMAND="sudo apt-get install libcups2-dev" ;;
3944     freetype)
3945       PKGHANDLER_COMMAND="sudo apt-get install libfreetype6-dev" ;;
3946     ffi)
3947       PKGHANDLER_COMMAND="sudo apt-get install libffi-dev" ;;
3948     x11)
3949       PKGHANDLER_COMMAND="sudo apt-get install libX11-dev libxext-dev libxrender-dev libxtst-dev libxt-dev" ;;
3950     ccache)
3951       PKGHANDLER_COMMAND="sudo apt-get install ccache" ;;
3952   esac
3953 }
3954 
3955 yum_help() {
3956   case $1 in
3957     devkit)
3958       PKGHANDLER_COMMAND="sudo yum groupinstall \"Development Tools\"" ;;
3959     openjdk)
3960       PKGHANDLER_COMMAND="sudo yum install java-1.7.0-openjdk" ;;
3961     alsa)
3962       PKGHANDLER_COMMAND="sudo yum install alsa-lib-devel" ;;
3963     cups)
3964       PKGHANDLER_COMMAND="sudo yum install cups-devel" ;;
3965     freetype)
3966       PKGHANDLER_COMMAND="sudo yum install freetype-devel" ;;
3967     x11)
3968       PKGHANDLER_COMMAND="sudo yum install libXtst-devel libXt-devel libXrender-devel libXi-devel" ;;
3969     ccache)
3970       PKGHANDLER_COMMAND="sudo yum install ccache" ;;
3971   esac
3972 }
3973 
3974 port_help() {
3975   PKGHANDLER_COMMAND=""
3976 }
3977 
3978 pkgutil_help() {
3979   PKGHANDLER_COMMAND=""
3980 }
3981 
3982 pkgadd_help() {
3983   PKGHANDLER_COMMAND=""
3984 }
3985 
3986 # This function will check if we're called from the "configure" wrapper while
3987 # printing --help. If so, we will print out additional information that can
3988 # only be extracted within the autoconf script, and then exit. This must be
3989 # called at the very beginning in configure.ac.
3990 
3991 
3992 
3993 
3994 
3995 
3996 #
3997 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
3998 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3999 #
4000 # This code is free software; you can redistribute it and/or modify it
4001 # under the terms of the GNU General Public License version 2 only, as
4002 # published by the Free Software Foundation.  Oracle designates this
4003 # particular file as subject to the "Classpath" exception as provided
4004 # by Oracle in the LICENSE file that accompanied this code.
4005 #
4006 # This code is distributed in the hope that it will be useful, but WITHOUT
4007 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4008 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4009 # version 2 for more details (a copy is included in the LICENSE file that
4010 # accompanied this code).
4011 #
4012 # You should have received a copy of the GNU General Public License version
4013 # 2 along with this work; if not, write to the Free Software Foundation,
4014 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4015 #
4016 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4017 # or visit www.oracle.com if you need additional information or have any
4018 # questions.
4019 #
4020 
4021 
4022 
4023 
4024 
4025 
4026 
4027 
4028 
4029 
4030 ###############################################################################
4031 #
4032 # Should we build only OpenJDK even if closed sources are present?
4033 #
4034 
4035 
4036 
4037 
4038 
4039 
4040 ###############################################################################
4041 #
4042 # Enable or disable the elliptic curve crypto implementation
4043 #
4044 
4045 
4046 
4047 
4048 
4049 ################################################################################
4050 #
4051 # Gcov coverage data for hotspot
4052 #
4053 
4054 









4055 #
4056 # Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
4057 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4058 #
4059 # This code is free software; you can redistribute it and/or modify it
4060 # under the terms of the GNU General Public License version 2 only, as
4061 # published by the Free Software Foundation.  Oracle designates this
4062 # particular file as subject to the "Classpath" exception as provided
4063 # by Oracle in the LICENSE file that accompanied this code.
4064 #
4065 # This code is distributed in the hope that it will be useful, but WITHOUT
4066 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4067 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4068 # version 2 for more details (a copy is included in the LICENSE file that
4069 # accompanied this code).
4070 #
4071 # You should have received a copy of the GNU General Public License version
4072 # 2 along with this work; if not, write to the Free Software Foundation,
4073 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4074 #
4075 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4076 # or visit www.oracle.com if you need additional information or have any
4077 # questions.
4078 #
4079 
4080 ###############################################################################
4081 #
4082 # Setup version numbers
4083 #
4084 
4085 # Verify that a given string represents a valid version number, and assign it
4086 # to a variable.
4087 
4088 # Argument 1: the variable to assign to
4089 # Argument 2: the value given by the user
4090 
4091 
4092 
4093 
4094 ################################################################################
4095 #
4096 # Static build support.  When enabled will generate static
4097 # libraries instead of shared libraries for all JDK libs.
4098 #
4099 
4100 
4101 
4102 
4103 #
4104 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
4105 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4106 #
4107 # This code is free software; you can redistribute it and/or modify it
4108 # under the terms of the GNU General Public License version 2 only, as
4109 # published by the Free Software Foundation.  Oracle designates this
4110 # particular file as subject to the "Classpath" exception as provided
4111 # by Oracle in the LICENSE file that accompanied this code.
4112 #
4113 # This code is distributed in the hope that it will be useful, but WITHOUT
4114 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4115 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4116 # version 2 for more details (a copy is included in the LICENSE file that
4117 # accompanied this code).
4118 #
4119 # You should have received a copy of the GNU General Public License version
4120 # 2 along with this work; if not, write to the Free Software Foundation,
4121 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4122 #
4123 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4124 # or visit www.oracle.com if you need additional information or have any
4125 # questions.
4126 #
4127 
4128 # Major library component reside in separate files.
4129 #
4130 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
4131 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4132 #
4133 # This code is free software; you can redistribute it and/or modify it
4134 # under the terms of the GNU General Public License version 2 only, as
4135 # published by the Free Software Foundation.  Oracle designates this
4136 # particular file as subject to the "Classpath" exception as provided
4137 # by Oracle in the LICENSE file that accompanied this code.
4138 #
4139 # This code is distributed in the hope that it will be useful, but WITHOUT
4140 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4141 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4142 # version 2 for more details (a copy is included in the LICENSE file that
4143 # accompanied this code).
4144 #
4145 # You should have received a copy of the GNU General Public License version
4146 # 2 along with this work; if not, write to the Free Software Foundation,
4147 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4148 #
4149 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4150 # or visit www.oracle.com if you need additional information or have any
4151 # questions.
4152 #
4153 
4154 ################################################################################
4155 # Setup alsa (Advanced Linux Sound Architecture)
4156 ################################################################################
4157 
4158 
4159 #
4160 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
4161 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4162 #
4163 # This code is free software; you can redistribute it and/or modify it
4164 # under the terms of the GNU General Public License version 2 only, as
4165 # published by the Free Software Foundation.  Oracle designates this
4166 # particular file as subject to the "Classpath" exception as provided
4167 # by Oracle in the LICENSE file that accompanied this code.
4168 #
4169 # This code is distributed in the hope that it will be useful, but WITHOUT
4170 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4171 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4172 # version 2 for more details (a copy is included in the LICENSE file that
4173 # accompanied this code).
4174 #
4175 # You should have received a copy of the GNU General Public License version
4176 # 2 along with this work; if not, write to the Free Software Foundation,
4177 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4178 #
4179 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4180 # or visit www.oracle.com if you need additional information or have any
4181 # questions.
4182 #
4183 
4184 ################################################################################
4185 # Setup bundled libraries.
4186 #
4187 # For libjpeg, giflib, libpng, lcms2 and zlib, the source is present in the
4188 # OpenJDK repository. Default is to use these libraries as bundled, but they
4189 # might be replaced by en external version by the user.
4190 ################################################################################
4191 
4192 
4193 ################################################################################
4194 # Setup libjpeg
4195 ################################################################################
4196 
4197 
4198 ################################################################################
4199 # Setup giflib
4200 ################################################################################
4201 
4202 
4203 ################################################################################
4204 # Setup libpng
4205 ################################################################################
4206 
4207 
4208 ################################################################################
4209 # Setup zlib
4210 ################################################################################
4211 
4212 
4213 ################################################################################
4214 # Setup lcms (Little CMS)
4215 ################################################################################
4216 
4217 
4218 #
4219 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
4220 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4221 #
4222 # This code is free software; you can redistribute it and/or modify it
4223 # under the terms of the GNU General Public License version 2 only, as
4224 # published by the Free Software Foundation.  Oracle designates this
4225 # particular file as subject to the "Classpath" exception as provided
4226 # by Oracle in the LICENSE file that accompanied this code.
4227 #
4228 # This code is distributed in the hope that it will be useful, but WITHOUT
4229 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4230 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4231 # version 2 for more details (a copy is included in the LICENSE file that
4232 # accompanied this code).
4233 #
4234 # You should have received a copy of the GNU General Public License version
4235 # 2 along with this work; if not, write to the Free Software Foundation,
4236 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4237 #
4238 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4239 # or visit www.oracle.com if you need additional information or have any
4240 # questions.
4241 #
4242 
4243 ################################################################################
4244 # Setup cups (Common Unix Printing System)
4245 ################################################################################
4246 
4247 
4248 #
4249 # Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
4250 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4251 #
4252 # This code is free software; you can redistribute it and/or modify it
4253 # under the terms of the GNU General Public License version 2 only, as
4254 # published by the Free Software Foundation.  Oracle designates this
4255 # particular file as subject to the "Classpath" exception as provided
4256 # by Oracle in the LICENSE file that accompanied this code.
4257 #
4258 # This code is distributed in the hope that it will be useful, but WITHOUT
4259 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4260 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4261 # version 2 for more details (a copy is included in the LICENSE file that
4262 # accompanied this code).
4263 #
4264 # You should have received a copy of the GNU General Public License version
4265 # 2 along with this work; if not, write to the Free Software Foundation,
4266 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4267 #
4268 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4269 # or visit www.oracle.com if you need additional information or have any
4270 # questions.
4271 #
4272 
4273 ################################################################################
4274 # Setup libffi (Foreign Function Interface)
4275 ################################################################################
4276 
4277 
4278 #
4279 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
4280 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4281 #
4282 # This code is free software; you can redistribute it and/or modify it
4283 # under the terms of the GNU General Public License version 2 only, as
4284 # published by the Free Software Foundation.  Oracle designates this
4285 # particular file as subject to the "Classpath" exception as provided
4286 # by Oracle in the LICENSE file that accompanied this code.
4287 #
4288 # This code is distributed in the hope that it will be useful, but WITHOUT
4289 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4290 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4291 # version 2 for more details (a copy is included in the LICENSE file that
4292 # accompanied this code).
4293 #
4294 # You should have received a copy of the GNU General Public License version
4295 # 2 along with this work; if not, write to the Free Software Foundation,
4296 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4297 #
4298 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4299 # or visit www.oracle.com if you need additional information or have any
4300 # questions.
4301 #
4302 
4303 ################################################################################
4304 # Build the freetype lib from source
4305 ################################################################################
4306 
4307 
4308 ################################################################################
4309 # Check if a potential freeype library match is correct and usable
4310 ################################################################################
4311 
4312 
4313 ################################################################################
4314 # Setup freetype (The FreeType2 font rendering library)
4315 ################################################################################
4316 
4317 
4318 #
4319 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
4320 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4321 #
4322 # This code is free software; you can redistribute it and/or modify it
4323 # under the terms of the GNU General Public License version 2 only, as
4324 # published by the Free Software Foundation.  Oracle designates this
4325 # particular file as subject to the "Classpath" exception as provided
4326 # by Oracle in the LICENSE file that accompanied this code.
4327 #
4328 # This code is distributed in the hope that it will be useful, but WITHOUT
4329 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4330 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4331 # version 2 for more details (a copy is included in the LICENSE file that
4332 # accompanied this code).
4333 #
4334 # You should have received a copy of the GNU General Public License version
4335 # 2 along with this work; if not, write to the Free Software Foundation,
4336 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4337 #
4338 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4339 # or visit www.oracle.com if you need additional information or have any
4340 # questions.
4341 #
4342 
4343 ################################################################################
4344 # Setup the standard C/C++ runtime libraries.
4345 #
4346 # Most importantly, determine if stdc++ should be linked statically or
4347 # dynamically.
4348 ################################################################################
4349 
4350 
4351 #
4352 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
4353 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4354 #
4355 # This code is free software; you can redistribute it and/or modify it
4356 # under the terms of the GNU General Public License version 2 only, as
4357 # published by the Free Software Foundation.  Oracle designates this
4358 # particular file as subject to the "Classpath" exception as provided
4359 # by Oracle in the LICENSE file that accompanied this code.
4360 #
4361 # This code is distributed in the hope that it will be useful, but WITHOUT
4362 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4363 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4364 # version 2 for more details (a copy is included in the LICENSE file that
4365 # accompanied this code).
4366 #
4367 # You should have received a copy of the GNU General Public License version
4368 # 2 along with this work; if not, write to the Free Software Foundation,
4369 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4370 #
4371 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4372 # or visit www.oracle.com if you need additional information or have any
4373 # questions.
4374 #
4375 
4376 ################################################################################
4377 # Setup X11 Windows system
4378 ################################################################################
4379 
4380 
4381 
4382 ################################################################################
4383 # Determine which libraries are needed for this configuration
4384 ################################################################################
4385 
4386 
4387 ################################################################################
4388 # Parse library options, and setup needed libraries
4389 ################################################################################
4390 
4391 
4392 ################################################################################
4393 # Setup llvm (Low-Level VM)
4394 ################################################################################
4395 
4396 
4397 ################################################################################
4398 # Setup various libraries, typically small system libraries
4399 ################################################################################
4400 
4401 
4402 #
4403 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
4404 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4405 #
4406 # This code is free software; you can redistribute it and/or modify it
4407 # under the terms of the GNU General Public License version 2 only, as
4408 # published by the Free Software Foundation.  Oracle designates this
4409 # particular file as subject to the "Classpath" exception as provided
4410 # by Oracle in the LICENSE file that accompanied this code.
4411 #
4412 # This code is distributed in the hope that it will be useful, but WITHOUT
4413 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4414 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4415 # version 2 for more details (a copy is included in the LICENSE file that
4416 # accompanied this code).
4417 #
4418 # You should have received a copy of the GNU General Public License version
4419 # 2 along with this work; if not, write to the Free Software Foundation,
4420 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4421 #
4422 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4423 # or visit www.oracle.com if you need additional information or have any
4424 # questions.
4425 #
4426 
4427 # Support macro for PLATFORM_EXTRACT_TARGET_AND_BUILD.
4428 # Converts autoconf style CPU name to OpenJDK style, into
4429 # VAR_CPU, VAR_CPU_ARCH, VAR_CPU_BITS and VAR_CPU_ENDIAN.
4430 
4431 
4432 # Support macro for PLATFORM_EXTRACT_TARGET_AND_BUILD.
4433 # Converts autoconf style OS name to OpenJDK style, into
4434 # VAR_OS, VAR_OS_TYPE and VAR_OS_ENV.
4435 
4436 
4437 # Expects $host_os $host_cpu $build_os and $build_cpu
4438 # and $with_target_bits to have been setup!
4439 #
4440 # Translate the standard triplet(quadruplet) definition
4441 # of the target/build system into OPENJDK_TARGET_OS, OPENJDK_TARGET_CPU,
4442 # OPENJDK_BUILD_OS, etc.
4443 
4444 
4445 # Check if a reduced build (32-bit on 64-bit platforms) is requested, and modify behaviour
4446 # accordingly. Must be done after setting up build and target system, but before
4447 # doing anything else with these values.
4448 
4449 
4450 # Setup the legacy variables, for controlling the old makefiles.
4451 #
4452 
4453 
4454 
4455 
4456 #%%% Build and target systems %%%
4457 
4458 
4459 
4460 
4461 # Support macro for PLATFORM_SETUP_OPENJDK_TARGET_BITS.
4462 # Add -mX to various FLAGS variables.
4463 
4464 
4465 
4466 
4467 
4468 
4469 #
4470 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
4471 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4472 #
4473 # This code is free software; you can redistribute it and/or modify it
4474 # under the terms of the GNU General Public License version 2 only, as
4475 # published by the Free Software Foundation.  Oracle designates this
4476 # particular file as subject to the "Classpath" exception as provided
4477 # by Oracle in the LICENSE file that accompanied this code.
4478 #
4479 # This code is distributed in the hope that it will be useful, but WITHOUT
4480 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4481 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4482 # version 2 for more details (a copy is included in the LICENSE file that
4483 # accompanied this code).
4484 #
4485 # You should have received a copy of the GNU General Public License version
4486 # 2 along with this work; if not, write to the Free Software Foundation,
4487 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4488 #
4489 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4490 # or visit www.oracle.com if you need additional information or have any
4491 # questions.
4492 #
4493 
4494 
4495 
4496 
4497 
4498 
4499 
4500 #
4501 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
4502 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4503 #
4504 # This code is free software; you can redistribute it and/or modify it
4505 # under the terms of the GNU General Public License version 2 only, as
4506 # published by the Free Software Foundation.  Oracle designates this
4507 # particular file as subject to the "Classpath" exception as provided
4508 # by Oracle in the LICENSE file that accompanied this code.
4509 #
4510 # This code is distributed in the hope that it will be useful, but WITHOUT
4511 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4512 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4513 # version 2 for more details (a copy is included in the LICENSE file that
4514 # accompanied this code).
4515 #
4516 # You should have received a copy of the GNU General Public License version
4517 # 2 along with this work; if not, write to the Free Software Foundation,
4518 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4519 #
4520 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4521 # or visit www.oracle.com if you need additional information or have any
4522 # questions.
4523 #
4524 
4525 ########################################################################
4526 # This file is responsible for detecting, verifying and setting up the
4527 # toolchain, i.e. the compiler, linker and related utilities. It will setup
4528 # proper paths to the binaries, but it will not setup any flags.
4529 #
4530 # The binaries used is determined by the toolchain type, which is the family of
4531 # compilers and related tools that are used.
4532 ########################################################################
4533 
4534 
4535 # All valid toolchains, regardless of platform (used by help.m4)
4536 VALID_TOOLCHAINS_all="gcc clang solstudio xlc microsoft"
4537 
4538 # These toolchains are valid on different platforms
4539 VALID_TOOLCHAINS_linux="gcc clang"
4540 VALID_TOOLCHAINS_solaris="solstudio"
4541 VALID_TOOLCHAINS_macosx="gcc clang"
4542 VALID_TOOLCHAINS_aix="xlc"
4543 VALID_TOOLCHAINS_windows="microsoft"
4544 
4545 # Toolchain descriptions
4546 TOOLCHAIN_DESCRIPTION_clang="clang/LLVM"
4547 TOOLCHAIN_DESCRIPTION_gcc="GNU Compiler Collection"
4548 TOOLCHAIN_DESCRIPTION_microsoft="Microsoft Visual Studio"
4549 TOOLCHAIN_DESCRIPTION_solstudio="Oracle Solaris Studio"
4550 TOOLCHAIN_DESCRIPTION_xlc="IBM XL C/C++"
4551 
4552 # Setup a number of variables describing how native output files are
4553 # named on this platform/toolchain.
4554 
4555 
4556 # Determine which toolchain type to use, and make sure it is valid for this
4557 # platform. Setup various information about the selected toolchain.
4558 
4559 
4560 # Before we start detecting the toolchain executables, we might need some
4561 # special setup, e.g. additional paths etc.
4562 
4563 
4564 # Restore path, etc
4565 
4566 
4567 # Check if a compiler is of the toolchain type we expect, and save the version
4568 # information from it. If the compiler does not match the expected type,
4569 # this function will abort using AC_MSG_ERROR. If it matches, the version will
4570 # be stored in CC_VERSION_NUMBER/CXX_VERSION_NUMBER (as a dotted number), and
4571 # the full version string in CC_VERSION_STRING/CXX_VERSION_STRING.
4572 #
4573 # $1 = compiler to test (CC or CXX)
4574 # $2 = human readable name of compiler (C or C++)
4575 
4576 
4577 # Try to locate the given C or C++ compiler in the path, or otherwise.
4578 #
4579 # $1 = compiler to test (CC or CXX)
4580 # $2 = human readable name of compiler (C or C++)
4581 # $3 = list of compiler names to search for
4582 
4583 
4584 # Detect the core components of the toolchain, i.e. the compilers (CC and CXX),
4585 # preprocessor (CPP and CXXCPP), the linker (LD), the assembler (AS) and the
4586 # archiver (AR). Verify that the compilers are correct according to the
4587 # toolchain type.
4588 
4589 
4590 # Setup additional tools that is considered a part of the toolchain, but not the
4591 # core part. Many of these are highly platform-specific and do not exist,
4592 # and/or are not needed on all platforms.
4593 
4594 
4595 # Setup the build tools (i.e, the compiler and linker used to build programs
4596 # that should be run on the build platform, not the target platform, as a build
4597 # helper). Since the non-cross-compile case uses the normal, target compilers
4598 # for this, we can only do this after these have been setup.
4599 
4600 
4601 # Setup legacy variables that are still needed as alternative ways to refer to
4602 # parts of the toolchain.
4603 
4604 
4605 # Do some additional checks on the detected tools.
4606 
4607 
4608 # Setup the JTReg Regression Test Harness.
4609 
4610 
4611 #
4612 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
4613 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4614 #
4615 # This code is free software; you can redistribute it and/or modify it
4616 # under the terms of the GNU General Public License version 2 only, as
4617 # published by the Free Software Foundation.  Oracle designates this
4618 # particular file as subject to the "Classpath" exception as provided
4619 # by Oracle in the LICENSE file that accompanied this code.
4620 #
4621 # This code is distributed in the hope that it will be useful, but WITHOUT
4622 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4623 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4624 # version 2 for more details (a copy is included in the LICENSE file that
4625 # accompanied this code).
4626 #
4627 # You should have received a copy of the GNU General Public License version
4628 # 2 along with this work; if not, write to the Free Software Foundation,
4629 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4630 #
4631 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4632 # or visit www.oracle.com if you need additional information or have any
4633 # questions.
4634 #
4635 
4636 ################################################################################
4637 # The order of these defines the priority by which we try to find them.
4638 VALID_VS_VERSIONS="2013 2012 2010"
4639 
4640 VS_DESCRIPTION_2010="Microsoft Visual Studio 2010"
4641 VS_VERSION_INTERNAL_2010=100
4642 VS_MSVCR_2010=msvcr100.dll
4643 # We don't use msvcp on Visual Studio 2010
4644 #VS_MSVCP_2010=msvcp100.dll
4645 VS_ENVVAR_2010="VS100COMNTOOLS"
4646 VS_VS_INSTALLDIR_2010="Microsoft Visual Studio 10.0"
4647 VS_SDK_INSTALLDIR_2010="Microsoft SDKs/Windows/v7.1"
4648 VS_VS_PLATFORM_NAME_2010="v100"
4649 VS_SDK_PLATFORM_NAME_2010="Windows7.1SDK"
4650 
4651 VS_DESCRIPTION_2012="Microsoft Visual Studio 2012"
4652 VS_VERSION_INTERNAL_2012=110
4653 VS_MSVCR_2012=msvcr110.dll
4654 VS_MSVCP_2012=msvcp110.dll
4655 VS_ENVVAR_2012="VS110COMNTOOLS"
4656 VS_VS_INSTALLDIR_2012="Microsoft Visual Studio 11.0"
4657 VS_SDK_INSTALLDIR_2012=
4658 VS_VS_PLATFORM_NAME_2012="v110"
4659 VS_SDK_PLATFORM_NAME_2012=
4660 
4661 VS_DESCRIPTION_2013="Microsoft Visual Studio 2013"
4662 VS_VERSION_INTERNAL_2013=120
4663 VS_MSVCR_2013=msvcr120.dll
4664 VS_MSVCP_2013=msvcp120.dll
4665 VS_ENVVAR_2013="VS120COMNTOOLS"
4666 VS_VS_INSTALLDIR_2013="Microsoft Visual Studio 12.0"
4667 VS_SDK_INSTALLDIR_2013=
4668 VS_VS_PLATFORM_NAME_2013="v120"
4669 VS_SDK_PLATFORM_NAME_2013=
4670 
4671 ################################################################################
4672 
4673 
4674 
4675 ################################################################################
4676 
4677 
4678 
4679 ################################################################################
4680 # Finds the bat or cmd file in Visual Studio or the SDK that sets up a proper
4681 # build environment and assigns it to VS_ENV_CMD
4682 
4683 
4684 ################################################################################
4685 
4686 
4687 
4688 ################################################################################
4689 # Check if the VS env variables were setup prior to running configure.
4690 # If not, then find vcvarsall.bat and run it automatically, and integrate
4691 # the set env variables into the spec file.
4692 
4693 
4694 
4695 
4696 
4697 
4698 
4699 
4700 
4701 
4702 
4703 
4704 
4705 
4706 # This line needs to be here, verbatim, after all includes and the dummy hook
4707 # definitions. It is replaced with custom functionality when building
4708 # custom sources.
4709 #CUSTOM_AUTOCONF_INCLUDE
4710 
4711 # Do not change or remove the following line, it is needed for consistency checks:
4712 DATE_WHEN_GENERATED=1449049746
4713 
4714 ###############################################################################
4715 #
4716 # Initialization / Boot-strapping
4717 #
4718 # The bootstrapping process needs to solve the "chicken or the egg" problem,
4719 # thus it jumps back and forth, each time gaining something needed later on.
4720 #
4721 ###############################################################################
4722 
4723 # If we are requested to print additional help, do that and then exit.
4724 # This must be the very first call.
4725 
4726   if test "x$CONFIGURE_PRINT_TOOLCHAIN_LIST" != x; then
4727     $PRINTF "The following toolchains are available as arguments to --with-toolchain-type.\n"
4728     $PRINTF "Which are valid to use depends on the build platform.\n"
4729     for toolchain in $VALID_TOOLCHAINS_all; do
4730       # Use indirect variable referencing
4731       toolchain_var_name=TOOLCHAIN_DESCRIPTION_$toolchain
4732       TOOLCHAIN_DESCRIPTION=${!toolchain_var_name}
4733       $PRINTF "  %-10s  %s\n" $toolchain "$TOOLCHAIN_DESCRIPTION"
4734     done
4735 
4736     # And now exit directly
4737     exit 0
4738   fi
4739 
4740 
4741 # Basic initialization that must happen first of all in the normal process.
4742 
4743   # Save the original command line. This is passed to us by the wrapper configure script.
4744 
4745   # Save the path variable before it gets changed
4746   ORIGINAL_PATH="$PATH"
4747 
4748   DATE_WHEN_CONFIGURED=`LANG=C date`
4749 
4750   { $as_echo "$as_me:${as_lineno-$LINENO}: Configuration created at $DATE_WHEN_CONFIGURED." >&5
4751 $as_echo "$as_me: Configuration created at $DATE_WHEN_CONFIGURED." >&6;}
4752   { $as_echo "$as_me:${as_lineno-$LINENO}: configure script generated at timestamp $DATE_WHEN_GENERATED." >&5
4753 $as_echo "$as_me: configure script generated at timestamp $DATE_WHEN_GENERATED." >&6;}
4754 
4755 
4756   # Start with tools that do not need have cross compilation support
4757   # and can be expected to be found in the default PATH. These tools are
4758   # used by configure.
4759 
4760   # First are all the simple required tools.
4761 
4762 
4763 
4764   # Publish this variable in the help.
4765 
4766 
4767   if [ -z "${BASENAME+x}" ]; then
4768     # The variable is not set by user, try to locate tool using the code snippet
4769     for ac_prog in basename
4770 do
4771   # Extract the first word of "$ac_prog", so it can be a program name with args.
4772 set dummy $ac_prog; ac_word=$2
4773 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4774 $as_echo_n "checking for $ac_word... " >&6; }
4775 if ${ac_cv_path_BASENAME+:} false; then :
4776   $as_echo_n "(cached) " >&6
4777 else
4778   case $BASENAME in
4779   [\\/]* | ?:[\\/]*)
4780   ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
4781   ;;
4782   *)
4783   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4784 for as_dir in $PATH
4785 do
4786   IFS=$as_save_IFS
4787   test -z "$as_dir" && as_dir=.
4788     for ac_exec_ext in '' $ac_executable_extensions; do
4789   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4790     ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
4791     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4792     break 2
4793   fi
4794 done
4795   done
4796 IFS=$as_save_IFS
4797 
4798   ;;
4799 esac
4800 fi
4801 BASENAME=$ac_cv_path_BASENAME
4802 if test -n "$BASENAME"; then
4803   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
4804 $as_echo "$BASENAME" >&6; }
4805 else
4806   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4807 $as_echo "no" >&6; }
4808 fi
4809 
4810 
4811   test -n "$BASENAME" && break
4812 done
4813 
4814   else
4815     # The variable is set, but is it from the command line or the environment?
4816 
4817     # Try to remove the string !BASENAME! from our list.
4818     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BASENAME!/}
4819     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
4820       # If it failed, the variable was not from the command line. Ignore it,
4821       # but warn the user (except for BASH, which is always set by the calling BASH).
4822       if test "xBASENAME" != xBASH; then
4823         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BASENAME from the environment. Use command line variables instead." >&5
4824 $as_echo "$as_me: WARNING: Ignoring value of BASENAME from the environment. Use command line variables instead." >&2;}
4825       fi
4826       # Try to locate tool using the code snippet
4827       for ac_prog in basename
4828 do
4829   # Extract the first word of "$ac_prog", so it can be a program name with args.
4830 set dummy $ac_prog; ac_word=$2
4831 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4832 $as_echo_n "checking for $ac_word... " >&6; }
4833 if ${ac_cv_path_BASENAME+:} false; then :
4834   $as_echo_n "(cached) " >&6
4835 else
4836   case $BASENAME in
4837   [\\/]* | ?:[\\/]*)
4838   ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
4839   ;;
4840   *)
4841   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4842 for as_dir in $PATH
4843 do
4844   IFS=$as_save_IFS
4845   test -z "$as_dir" && as_dir=.
4846     for ac_exec_ext in '' $ac_executable_extensions; do
4847   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4848     ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
4849     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4850     break 2
4851   fi
4852 done
4853   done
4854 IFS=$as_save_IFS
4855 
4856   ;;
4857 esac
4858 fi
4859 BASENAME=$ac_cv_path_BASENAME
4860 if test -n "$BASENAME"; then
4861   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
4862 $as_echo "$BASENAME" >&6; }
4863 else
4864   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4865 $as_echo "no" >&6; }
4866 fi
4867 
4868 
4869   test -n "$BASENAME" && break
4870 done
4871 
4872     else
4873       # If it succeeded, then it was overridden by the user. We will use it
4874       # for the tool.
4875 
4876       # First remove it from the list of overridden variables, so we can test
4877       # for unknown variables in the end.
4878       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
4879 
4880       # Check if we try to supply an empty value
4881       if test "x$BASENAME" = x; then
4882         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool BASENAME= (no value)" >&5
4883 $as_echo "$as_me: Setting user supplied tool BASENAME= (no value)" >&6;}
4884         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASENAME" >&5
4885 $as_echo_n "checking for BASENAME... " >&6; }
4886         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
4887 $as_echo "disabled" >&6; }
4888       else
4889         # Check if the provided tool contains a complete path.
4890         tool_specified="$BASENAME"
4891         tool_basename="${tool_specified##*/}"
4892         if test "x$tool_basename" = "x$tool_specified"; then
4893           # A command without a complete path is provided, search $PATH.
4894           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BASENAME=$tool_basename" >&5
4895 $as_echo "$as_me: Will search for user supplied tool BASENAME=$tool_basename" >&6;}
4896           # Extract the first word of "$tool_basename", so it can be a program name with args.
4897 set dummy $tool_basename; ac_word=$2
4898 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4899 $as_echo_n "checking for $ac_word... " >&6; }
4900 if ${ac_cv_path_BASENAME+:} false; then :
4901   $as_echo_n "(cached) " >&6
4902 else
4903   case $BASENAME in
4904   [\\/]* | ?:[\\/]*)
4905   ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
4906   ;;
4907   *)
4908   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4909 for as_dir in $PATH
4910 do
4911   IFS=$as_save_IFS
4912   test -z "$as_dir" && as_dir=.
4913     for ac_exec_ext in '' $ac_executable_extensions; do
4914   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4915     ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
4916     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4917     break 2
4918   fi
4919 done
4920   done
4921 IFS=$as_save_IFS
4922 
4923   ;;
4924 esac
4925 fi
4926 BASENAME=$ac_cv_path_BASENAME
4927 if test -n "$BASENAME"; then
4928   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
4929 $as_echo "$BASENAME" >&6; }
4930 else
4931   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4932 $as_echo "no" >&6; }
4933 fi
4934 
4935 
4936           if test "x$BASENAME" = x; then
4937             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
4938           fi
4939         else
4940           # Otherwise we believe it is a complete path. Use it as it is.
4941           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BASENAME=$tool_specified" >&5
4942 $as_echo "$as_me: Will use user supplied tool BASENAME=$tool_specified" >&6;}
4943           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASENAME" >&5
4944 $as_echo_n "checking for BASENAME... " >&6; }
4945           if test ! -x "$tool_specified"; then
4946             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
4947 $as_echo "not found" >&6; }
4948             as_fn_error $? "User supplied tool BASENAME=$tool_specified does not exist or is not executable" "$LINENO" 5
4949           fi
4950           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
4951 $as_echo "$tool_specified" >&6; }
4952         fi
4953       fi
4954     fi
4955 
4956   fi
4957 
4958 
4959 
4960   if test "x$BASENAME" = x; then
4961     as_fn_error $? "Could not find required tool for BASENAME" "$LINENO" 5
4962   fi
4963 
4964 
4965 
4966 
4967 
4968   # Publish this variable in the help.
4969 
4970 
4971   if [ -z "${BASH+x}" ]; then
4972     # The variable is not set by user, try to locate tool using the code snippet
4973     for ac_prog in bash
4974 do
4975   # Extract the first word of "$ac_prog", so it can be a program name with args.
4976 set dummy $ac_prog; ac_word=$2
4977 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4978 $as_echo_n "checking for $ac_word... " >&6; }
4979 if ${ac_cv_path_BASH+:} false; then :
4980   $as_echo_n "(cached) " >&6
4981 else
4982   case $BASH in
4983   [\\/]* | ?:[\\/]*)
4984   ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
4985   ;;
4986   *)
4987   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4988 for as_dir in $PATH
4989 do
4990   IFS=$as_save_IFS
4991   test -z "$as_dir" && as_dir=.
4992     for ac_exec_ext in '' $ac_executable_extensions; do
4993   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4994     ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
4995     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4996     break 2
4997   fi
4998 done
4999   done
5000 IFS=$as_save_IFS
5001 
5002   ;;
5003 esac
5004 fi
5005 BASH=$ac_cv_path_BASH
5006 if test -n "$BASH"; then
5007   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
5008 $as_echo "$BASH" >&6; }
5009 else
5010   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5011 $as_echo "no" >&6; }
5012 fi
5013 
5014 
5015   test -n "$BASH" && break
5016 done
5017 
5018   else
5019     # The variable is set, but is it from the command line or the environment?
5020 
5021     # Try to remove the string !BASH! from our list.
5022     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BASH!/}
5023     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5024       # If it failed, the variable was not from the command line. Ignore it,
5025       # but warn the user (except for BASH, which is always set by the calling BASH).
5026       if test "xBASH" != xBASH; then
5027         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BASH from the environment. Use command line variables instead." >&5
5028 $as_echo "$as_me: WARNING: Ignoring value of BASH from the environment. Use command line variables instead." >&2;}
5029       fi
5030       # Try to locate tool using the code snippet
5031       for ac_prog in bash
5032 do
5033   # Extract the first word of "$ac_prog", so it can be a program name with args.
5034 set dummy $ac_prog; ac_word=$2
5035 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5036 $as_echo_n "checking for $ac_word... " >&6; }
5037 if ${ac_cv_path_BASH+:} false; then :
5038   $as_echo_n "(cached) " >&6
5039 else
5040   case $BASH in
5041   [\\/]* | ?:[\\/]*)
5042   ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
5043   ;;
5044   *)
5045   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5046 for as_dir in $PATH
5047 do
5048   IFS=$as_save_IFS
5049   test -z "$as_dir" && as_dir=.
5050     for ac_exec_ext in '' $ac_executable_extensions; do
5051   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5052     ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
5053     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5054     break 2
5055   fi
5056 done
5057   done
5058 IFS=$as_save_IFS
5059 
5060   ;;
5061 esac
5062 fi
5063 BASH=$ac_cv_path_BASH
5064 if test -n "$BASH"; then
5065   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
5066 $as_echo "$BASH" >&6; }
5067 else
5068   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5069 $as_echo "no" >&6; }
5070 fi
5071 
5072 
5073   test -n "$BASH" && break
5074 done
5075 
5076     else
5077       # If it succeeded, then it was overridden by the user. We will use it
5078       # for the tool.
5079 
5080       # First remove it from the list of overridden variables, so we can test
5081       # for unknown variables in the end.
5082       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5083 
5084       # Check if we try to supply an empty value
5085       if test "x$BASH" = x; then
5086         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool BASH= (no value)" >&5
5087 $as_echo "$as_me: Setting user supplied tool BASH= (no value)" >&6;}
5088         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASH" >&5
5089 $as_echo_n "checking for BASH... " >&6; }
5090         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
5091 $as_echo "disabled" >&6; }
5092       else
5093         # Check if the provided tool contains a complete path.
5094         tool_specified="$BASH"
5095         tool_basename="${tool_specified##*/}"
5096         if test "x$tool_basename" = "x$tool_specified"; then
5097           # A command without a complete path is provided, search $PATH.
5098           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BASH=$tool_basename" >&5
5099 $as_echo "$as_me: Will search for user supplied tool BASH=$tool_basename" >&6;}
5100           # Extract the first word of "$tool_basename", so it can be a program name with args.
5101 set dummy $tool_basename; ac_word=$2
5102 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5103 $as_echo_n "checking for $ac_word... " >&6; }
5104 if ${ac_cv_path_BASH+:} false; then :
5105   $as_echo_n "(cached) " >&6
5106 else
5107   case $BASH in
5108   [\\/]* | ?:[\\/]*)
5109   ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
5110   ;;
5111   *)
5112   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5113 for as_dir in $PATH
5114 do
5115   IFS=$as_save_IFS
5116   test -z "$as_dir" && as_dir=.
5117     for ac_exec_ext in '' $ac_executable_extensions; do
5118   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5119     ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
5120     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5121     break 2
5122   fi
5123 done
5124   done
5125 IFS=$as_save_IFS
5126 
5127   ;;
5128 esac
5129 fi
5130 BASH=$ac_cv_path_BASH
5131 if test -n "$BASH"; then
5132   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
5133 $as_echo "$BASH" >&6; }
5134 else
5135   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5136 $as_echo "no" >&6; }
5137 fi
5138 
5139 
5140           if test "x$BASH" = x; then
5141             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5142           fi
5143         else
5144           # Otherwise we believe it is a complete path. Use it as it is.
5145           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BASH=$tool_specified" >&5
5146 $as_echo "$as_me: Will use user supplied tool BASH=$tool_specified" >&6;}
5147           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASH" >&5
5148 $as_echo_n "checking for BASH... " >&6; }
5149           if test ! -x "$tool_specified"; then
5150             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5151 $as_echo "not found" >&6; }
5152             as_fn_error $? "User supplied tool BASH=$tool_specified does not exist or is not executable" "$LINENO" 5
5153           fi
5154           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5155 $as_echo "$tool_specified" >&6; }
5156         fi
5157       fi
5158     fi
5159 
5160   fi
5161 
5162 
5163 
5164   if test "x$BASH" = x; then
5165     as_fn_error $? "Could not find required tool for BASH" "$LINENO" 5
5166   fi
5167 
5168 
5169 
5170 
5171 
5172   # Publish this variable in the help.
5173 
5174 
5175   if [ -z "${CAT+x}" ]; then
5176     # The variable is not set by user, try to locate tool using the code snippet
5177     for ac_prog in cat
5178 do
5179   # Extract the first word of "$ac_prog", so it can be a program name with args.
5180 set dummy $ac_prog; ac_word=$2
5181 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5182 $as_echo_n "checking for $ac_word... " >&6; }
5183 if ${ac_cv_path_CAT+:} false; then :
5184   $as_echo_n "(cached) " >&6
5185 else
5186   case $CAT in
5187   [\\/]* | ?:[\\/]*)
5188   ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
5189   ;;
5190   *)
5191   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5192 for as_dir in $PATH
5193 do
5194   IFS=$as_save_IFS
5195   test -z "$as_dir" && as_dir=.
5196     for ac_exec_ext in '' $ac_executable_extensions; do
5197   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5198     ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
5199     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5200     break 2
5201   fi
5202 done
5203   done
5204 IFS=$as_save_IFS
5205 
5206   ;;
5207 esac
5208 fi
5209 CAT=$ac_cv_path_CAT
5210 if test -n "$CAT"; then
5211   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
5212 $as_echo "$CAT" >&6; }
5213 else
5214   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5215 $as_echo "no" >&6; }
5216 fi
5217 
5218 
5219   test -n "$CAT" && break
5220 done
5221 
5222   else
5223     # The variable is set, but is it from the command line or the environment?
5224 
5225     # Try to remove the string !CAT! from our list.
5226     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CAT!/}
5227     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5228       # If it failed, the variable was not from the command line. Ignore it,
5229       # but warn the user (except for BASH, which is always set by the calling BASH).
5230       if test "xCAT" != xBASH; then
5231         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CAT from the environment. Use command line variables instead." >&5
5232 $as_echo "$as_me: WARNING: Ignoring value of CAT from the environment. Use command line variables instead." >&2;}
5233       fi
5234       # Try to locate tool using the code snippet
5235       for ac_prog in cat
5236 do
5237   # Extract the first word of "$ac_prog", so it can be a program name with args.
5238 set dummy $ac_prog; ac_word=$2
5239 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5240 $as_echo_n "checking for $ac_word... " >&6; }
5241 if ${ac_cv_path_CAT+:} false; then :
5242   $as_echo_n "(cached) " >&6
5243 else
5244   case $CAT in
5245   [\\/]* | ?:[\\/]*)
5246   ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
5247   ;;
5248   *)
5249   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5250 for as_dir in $PATH
5251 do
5252   IFS=$as_save_IFS
5253   test -z "$as_dir" && as_dir=.
5254     for ac_exec_ext in '' $ac_executable_extensions; do
5255   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5256     ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
5257     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5258     break 2
5259   fi
5260 done
5261   done
5262 IFS=$as_save_IFS
5263 
5264   ;;
5265 esac
5266 fi
5267 CAT=$ac_cv_path_CAT
5268 if test -n "$CAT"; then
5269   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
5270 $as_echo "$CAT" >&6; }
5271 else
5272   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5273 $as_echo "no" >&6; }
5274 fi
5275 
5276 
5277   test -n "$CAT" && break
5278 done
5279 
5280     else
5281       # If it succeeded, then it was overridden by the user. We will use it
5282       # for the tool.
5283 
5284       # First remove it from the list of overridden variables, so we can test
5285       # for unknown variables in the end.
5286       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5287 
5288       # Check if we try to supply an empty value
5289       if test "x$CAT" = x; then
5290         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CAT= (no value)" >&5
5291 $as_echo "$as_me: Setting user supplied tool CAT= (no value)" >&6;}
5292         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CAT" >&5
5293 $as_echo_n "checking for CAT... " >&6; }
5294         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
5295 $as_echo "disabled" >&6; }
5296       else
5297         # Check if the provided tool contains a complete path.
5298         tool_specified="$CAT"
5299         tool_basename="${tool_specified##*/}"
5300         if test "x$tool_basename" = "x$tool_specified"; then
5301           # A command without a complete path is provided, search $PATH.
5302           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CAT=$tool_basename" >&5
5303 $as_echo "$as_me: Will search for user supplied tool CAT=$tool_basename" >&6;}
5304           # Extract the first word of "$tool_basename", so it can be a program name with args.
5305 set dummy $tool_basename; ac_word=$2
5306 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5307 $as_echo_n "checking for $ac_word... " >&6; }
5308 if ${ac_cv_path_CAT+:} false; then :
5309   $as_echo_n "(cached) " >&6
5310 else
5311   case $CAT in
5312   [\\/]* | ?:[\\/]*)
5313   ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
5314   ;;
5315   *)
5316   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5317 for as_dir in $PATH
5318 do
5319   IFS=$as_save_IFS
5320   test -z "$as_dir" && as_dir=.
5321     for ac_exec_ext in '' $ac_executable_extensions; do
5322   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5323     ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
5324     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5325     break 2
5326   fi
5327 done
5328   done
5329 IFS=$as_save_IFS
5330 
5331   ;;
5332 esac
5333 fi
5334 CAT=$ac_cv_path_CAT
5335 if test -n "$CAT"; then
5336   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
5337 $as_echo "$CAT" >&6; }
5338 else
5339   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5340 $as_echo "no" >&6; }
5341 fi
5342 
5343 
5344           if test "x$CAT" = x; then
5345             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5346           fi
5347         else
5348           # Otherwise we believe it is a complete path. Use it as it is.
5349           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CAT=$tool_specified" >&5
5350 $as_echo "$as_me: Will use user supplied tool CAT=$tool_specified" >&6;}
5351           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CAT" >&5
5352 $as_echo_n "checking for CAT... " >&6; }
5353           if test ! -x "$tool_specified"; then
5354             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5355 $as_echo "not found" >&6; }
5356             as_fn_error $? "User supplied tool CAT=$tool_specified does not exist or is not executable" "$LINENO" 5
5357           fi
5358           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5359 $as_echo "$tool_specified" >&6; }
5360         fi
5361       fi
5362     fi
5363 
5364   fi
5365 
5366 
5367 
5368   if test "x$CAT" = x; then
5369     as_fn_error $? "Could not find required tool for CAT" "$LINENO" 5
5370   fi
5371 
5372 
5373 
5374 
5375 
5376   # Publish this variable in the help.
5377 
5378 
5379   if [ -z "${CHMOD+x}" ]; then
5380     # The variable is not set by user, try to locate tool using the code snippet
5381     for ac_prog in chmod
5382 do
5383   # Extract the first word of "$ac_prog", so it can be a program name with args.
5384 set dummy $ac_prog; ac_word=$2
5385 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5386 $as_echo_n "checking for $ac_word... " >&6; }
5387 if ${ac_cv_path_CHMOD+:} false; then :
5388   $as_echo_n "(cached) " >&6
5389 else
5390   case $CHMOD in
5391   [\\/]* | ?:[\\/]*)
5392   ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
5393   ;;
5394   *)
5395   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5396 for as_dir in $PATH
5397 do
5398   IFS=$as_save_IFS
5399   test -z "$as_dir" && as_dir=.
5400     for ac_exec_ext in '' $ac_executable_extensions; do
5401   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5402     ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
5403     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5404     break 2
5405   fi
5406 done
5407   done
5408 IFS=$as_save_IFS
5409 
5410   ;;
5411 esac
5412 fi
5413 CHMOD=$ac_cv_path_CHMOD
5414 if test -n "$CHMOD"; then
5415   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
5416 $as_echo "$CHMOD" >&6; }
5417 else
5418   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5419 $as_echo "no" >&6; }
5420 fi
5421 
5422 
5423   test -n "$CHMOD" && break
5424 done
5425 
5426   else
5427     # The variable is set, but is it from the command line or the environment?
5428 
5429     # Try to remove the string !CHMOD! from our list.
5430     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CHMOD!/}
5431     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5432       # If it failed, the variable was not from the command line. Ignore it,
5433       # but warn the user (except for BASH, which is always set by the calling BASH).
5434       if test "xCHMOD" != xBASH; then
5435         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CHMOD from the environment. Use command line variables instead." >&5
5436 $as_echo "$as_me: WARNING: Ignoring value of CHMOD from the environment. Use command line variables instead." >&2;}
5437       fi
5438       # Try to locate tool using the code snippet
5439       for ac_prog in chmod
5440 do
5441   # Extract the first word of "$ac_prog", so it can be a program name with args.
5442 set dummy $ac_prog; ac_word=$2
5443 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5444 $as_echo_n "checking for $ac_word... " >&6; }
5445 if ${ac_cv_path_CHMOD+:} false; then :
5446   $as_echo_n "(cached) " >&6
5447 else
5448   case $CHMOD in
5449   [\\/]* | ?:[\\/]*)
5450   ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
5451   ;;
5452   *)
5453   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5454 for as_dir in $PATH
5455 do
5456   IFS=$as_save_IFS
5457   test -z "$as_dir" && as_dir=.
5458     for ac_exec_ext in '' $ac_executable_extensions; do
5459   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5460     ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
5461     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5462     break 2
5463   fi
5464 done
5465   done
5466 IFS=$as_save_IFS
5467 
5468   ;;
5469 esac
5470 fi
5471 CHMOD=$ac_cv_path_CHMOD
5472 if test -n "$CHMOD"; then
5473   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
5474 $as_echo "$CHMOD" >&6; }
5475 else
5476   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5477 $as_echo "no" >&6; }
5478 fi
5479 
5480 
5481   test -n "$CHMOD" && break
5482 done
5483 
5484     else
5485       # If it succeeded, then it was overridden by the user. We will use it
5486       # for the tool.
5487 
5488       # First remove it from the list of overridden variables, so we can test
5489       # for unknown variables in the end.
5490       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5491 
5492       # Check if we try to supply an empty value
5493       if test "x$CHMOD" = x; then
5494         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CHMOD= (no value)" >&5
5495 $as_echo "$as_me: Setting user supplied tool CHMOD= (no value)" >&6;}
5496         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CHMOD" >&5
5497 $as_echo_n "checking for CHMOD... " >&6; }
5498         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
5499 $as_echo "disabled" >&6; }
5500       else
5501         # Check if the provided tool contains a complete path.
5502         tool_specified="$CHMOD"
5503         tool_basename="${tool_specified##*/}"
5504         if test "x$tool_basename" = "x$tool_specified"; then
5505           # A command without a complete path is provided, search $PATH.
5506           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CHMOD=$tool_basename" >&5
5507 $as_echo "$as_me: Will search for user supplied tool CHMOD=$tool_basename" >&6;}
5508           # Extract the first word of "$tool_basename", so it can be a program name with args.
5509 set dummy $tool_basename; ac_word=$2
5510 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5511 $as_echo_n "checking for $ac_word... " >&6; }
5512 if ${ac_cv_path_CHMOD+:} false; then :
5513   $as_echo_n "(cached) " >&6
5514 else
5515   case $CHMOD in
5516   [\\/]* | ?:[\\/]*)
5517   ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
5518   ;;
5519   *)
5520   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5521 for as_dir in $PATH
5522 do
5523   IFS=$as_save_IFS
5524   test -z "$as_dir" && as_dir=.
5525     for ac_exec_ext in '' $ac_executable_extensions; do
5526   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5527     ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
5528     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5529     break 2
5530   fi
5531 done
5532   done
5533 IFS=$as_save_IFS
5534 
5535   ;;
5536 esac
5537 fi
5538 CHMOD=$ac_cv_path_CHMOD
5539 if test -n "$CHMOD"; then
5540   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
5541 $as_echo "$CHMOD" >&6; }
5542 else
5543   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5544 $as_echo "no" >&6; }
5545 fi
5546 
5547 
5548           if test "x$CHMOD" = x; then
5549             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5550           fi
5551         else
5552           # Otherwise we believe it is a complete path. Use it as it is.
5553           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CHMOD=$tool_specified" >&5
5554 $as_echo "$as_me: Will use user supplied tool CHMOD=$tool_specified" >&6;}
5555           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CHMOD" >&5
5556 $as_echo_n "checking for CHMOD... " >&6; }
5557           if test ! -x "$tool_specified"; then
5558             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5559 $as_echo "not found" >&6; }
5560             as_fn_error $? "User supplied tool CHMOD=$tool_specified does not exist or is not executable" "$LINENO" 5
5561           fi
5562           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5563 $as_echo "$tool_specified" >&6; }
5564         fi
5565       fi
5566     fi
5567 
5568   fi
5569 
5570 
5571 
5572   if test "x$CHMOD" = x; then
5573     as_fn_error $? "Could not find required tool for CHMOD" "$LINENO" 5
5574   fi
5575 
5576 
5577 
5578 
5579 
5580   # Publish this variable in the help.
5581 
5582 
5583   if [ -z "${CMP+x}" ]; then
5584     # The variable is not set by user, try to locate tool using the code snippet
5585     for ac_prog in cmp
5586 do
5587   # Extract the first word of "$ac_prog", so it can be a program name with args.
5588 set dummy $ac_prog; ac_word=$2
5589 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5590 $as_echo_n "checking for $ac_word... " >&6; }
5591 if ${ac_cv_path_CMP+:} false; then :
5592   $as_echo_n "(cached) " >&6
5593 else
5594   case $CMP in
5595   [\\/]* | ?:[\\/]*)
5596   ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
5597   ;;
5598   *)
5599   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5600 for as_dir in $PATH
5601 do
5602   IFS=$as_save_IFS
5603   test -z "$as_dir" && as_dir=.
5604     for ac_exec_ext in '' $ac_executable_extensions; do
5605   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5606     ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
5607     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5608     break 2
5609   fi
5610 done
5611   done
5612 IFS=$as_save_IFS
5613 
5614   ;;
5615 esac
5616 fi
5617 CMP=$ac_cv_path_CMP
5618 if test -n "$CMP"; then
5619   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
5620 $as_echo "$CMP" >&6; }
5621 else
5622   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5623 $as_echo "no" >&6; }
5624 fi
5625 
5626 
5627   test -n "$CMP" && break
5628 done
5629 
5630   else
5631     # The variable is set, but is it from the command line or the environment?
5632 
5633     # Try to remove the string !CMP! from our list.
5634     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CMP!/}
5635     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5636       # If it failed, the variable was not from the command line. Ignore it,
5637       # but warn the user (except for BASH, which is always set by the calling BASH).
5638       if test "xCMP" != xBASH; then
5639         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CMP from the environment. Use command line variables instead." >&5
5640 $as_echo "$as_me: WARNING: Ignoring value of CMP from the environment. Use command line variables instead." >&2;}
5641       fi
5642       # Try to locate tool using the code snippet
5643       for ac_prog in cmp
5644 do
5645   # Extract the first word of "$ac_prog", so it can be a program name with args.
5646 set dummy $ac_prog; ac_word=$2
5647 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5648 $as_echo_n "checking for $ac_word... " >&6; }
5649 if ${ac_cv_path_CMP+:} false; then :
5650   $as_echo_n "(cached) " >&6
5651 else
5652   case $CMP in
5653   [\\/]* | ?:[\\/]*)
5654   ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
5655   ;;
5656   *)
5657   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5658 for as_dir in $PATH
5659 do
5660   IFS=$as_save_IFS
5661   test -z "$as_dir" && as_dir=.
5662     for ac_exec_ext in '' $ac_executable_extensions; do
5663   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5664     ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
5665     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5666     break 2
5667   fi
5668 done
5669   done
5670 IFS=$as_save_IFS
5671 
5672   ;;
5673 esac
5674 fi
5675 CMP=$ac_cv_path_CMP
5676 if test -n "$CMP"; then
5677   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
5678 $as_echo "$CMP" >&6; }
5679 else
5680   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5681 $as_echo "no" >&6; }
5682 fi
5683 
5684 
5685   test -n "$CMP" && break
5686 done
5687 
5688     else
5689       # If it succeeded, then it was overridden by the user. We will use it
5690       # for the tool.
5691 
5692       # First remove it from the list of overridden variables, so we can test
5693       # for unknown variables in the end.
5694       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5695 
5696       # Check if we try to supply an empty value
5697       if test "x$CMP" = x; then
5698         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CMP= (no value)" >&5
5699 $as_echo "$as_me: Setting user supplied tool CMP= (no value)" >&6;}
5700         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CMP" >&5
5701 $as_echo_n "checking for CMP... " >&6; }
5702         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
5703 $as_echo "disabled" >&6; }
5704       else
5705         # Check if the provided tool contains a complete path.
5706         tool_specified="$CMP"
5707         tool_basename="${tool_specified##*/}"
5708         if test "x$tool_basename" = "x$tool_specified"; then
5709           # A command without a complete path is provided, search $PATH.
5710           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CMP=$tool_basename" >&5
5711 $as_echo "$as_me: Will search for user supplied tool CMP=$tool_basename" >&6;}
5712           # Extract the first word of "$tool_basename", so it can be a program name with args.
5713 set dummy $tool_basename; ac_word=$2
5714 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5715 $as_echo_n "checking for $ac_word... " >&6; }
5716 if ${ac_cv_path_CMP+:} false; then :
5717   $as_echo_n "(cached) " >&6
5718 else
5719   case $CMP in
5720   [\\/]* | ?:[\\/]*)
5721   ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
5722   ;;
5723   *)
5724   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5725 for as_dir in $PATH
5726 do
5727   IFS=$as_save_IFS
5728   test -z "$as_dir" && as_dir=.
5729     for ac_exec_ext in '' $ac_executable_extensions; do
5730   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5731     ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
5732     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5733     break 2
5734   fi
5735 done
5736   done
5737 IFS=$as_save_IFS
5738 
5739   ;;
5740 esac
5741 fi
5742 CMP=$ac_cv_path_CMP
5743 if test -n "$CMP"; then
5744   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
5745 $as_echo "$CMP" >&6; }
5746 else
5747   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5748 $as_echo "no" >&6; }
5749 fi
5750 
5751 
5752           if test "x$CMP" = x; then
5753             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5754           fi
5755         else
5756           # Otherwise we believe it is a complete path. Use it as it is.
5757           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CMP=$tool_specified" >&5
5758 $as_echo "$as_me: Will use user supplied tool CMP=$tool_specified" >&6;}
5759           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CMP" >&5
5760 $as_echo_n "checking for CMP... " >&6; }
5761           if test ! -x "$tool_specified"; then
5762             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5763 $as_echo "not found" >&6; }
5764             as_fn_error $? "User supplied tool CMP=$tool_specified does not exist or is not executable" "$LINENO" 5
5765           fi
5766           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5767 $as_echo "$tool_specified" >&6; }
5768         fi
5769       fi
5770     fi
5771 
5772   fi
5773 
5774 
5775 
5776   if test "x$CMP" = x; then
5777     as_fn_error $? "Could not find required tool for CMP" "$LINENO" 5
5778   fi
5779 
5780 
5781 
5782 
5783 
5784   # Publish this variable in the help.
5785 
5786 
5787   if [ -z "${COMM+x}" ]; then
5788     # The variable is not set by user, try to locate tool using the code snippet
5789     for ac_prog in comm
5790 do
5791   # Extract the first word of "$ac_prog", so it can be a program name with args.
5792 set dummy $ac_prog; ac_word=$2
5793 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5794 $as_echo_n "checking for $ac_word... " >&6; }
5795 if ${ac_cv_path_COMM+:} false; then :
5796   $as_echo_n "(cached) " >&6
5797 else
5798   case $COMM in
5799   [\\/]* | ?:[\\/]*)
5800   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
5801   ;;
5802   *)
5803   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5804 for as_dir in $PATH
5805 do
5806   IFS=$as_save_IFS
5807   test -z "$as_dir" && as_dir=.
5808     for ac_exec_ext in '' $ac_executable_extensions; do
5809   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5810     ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
5811     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5812     break 2
5813   fi
5814 done
5815   done
5816 IFS=$as_save_IFS
5817 
5818   ;;
5819 esac
5820 fi
5821 COMM=$ac_cv_path_COMM
5822 if test -n "$COMM"; then
5823   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
5824 $as_echo "$COMM" >&6; }
5825 else
5826   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5827 $as_echo "no" >&6; }
5828 fi
5829 
5830 
5831   test -n "$COMM" && break
5832 done
5833 
5834   else
5835     # The variable is set, but is it from the command line or the environment?
5836 
5837     # Try to remove the string !COMM! from our list.
5838     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!COMM!/}
5839     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5840       # If it failed, the variable was not from the command line. Ignore it,
5841       # but warn the user (except for BASH, which is always set by the calling BASH).
5842       if test "xCOMM" != xBASH; then
5843         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&5
5844 $as_echo "$as_me: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&2;}
5845       fi
5846       # Try to locate tool using the code snippet
5847       for ac_prog in comm
5848 do
5849   # Extract the first word of "$ac_prog", so it can be a program name with args.
5850 set dummy $ac_prog; ac_word=$2
5851 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5852 $as_echo_n "checking for $ac_word... " >&6; }
5853 if ${ac_cv_path_COMM+:} false; then :
5854   $as_echo_n "(cached) " >&6
5855 else
5856   case $COMM in
5857   [\\/]* | ?:[\\/]*)
5858   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
5859   ;;
5860   *)
5861   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5862 for as_dir in $PATH
5863 do
5864   IFS=$as_save_IFS
5865   test -z "$as_dir" && as_dir=.
5866     for ac_exec_ext in '' $ac_executable_extensions; do
5867   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5868     ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
5869     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5870     break 2
5871   fi
5872 done
5873   done
5874 IFS=$as_save_IFS
5875 
5876   ;;
5877 esac
5878 fi
5879 COMM=$ac_cv_path_COMM
5880 if test -n "$COMM"; then
5881   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
5882 $as_echo "$COMM" >&6; }
5883 else
5884   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5885 $as_echo "no" >&6; }
5886 fi
5887 
5888 
5889   test -n "$COMM" && break
5890 done
5891 
5892     else
5893       # If it succeeded, then it was overridden by the user. We will use it
5894       # for the tool.
5895 
5896       # First remove it from the list of overridden variables, so we can test
5897       # for unknown variables in the end.
5898       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5899 
5900       # Check if we try to supply an empty value
5901       if test "x$COMM" = x; then
5902         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool COMM= (no value)" >&5
5903 $as_echo "$as_me: Setting user supplied tool COMM= (no value)" >&6;}
5904         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for COMM" >&5
5905 $as_echo_n "checking for COMM... " >&6; }
5906         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
5907 $as_echo "disabled" >&6; }
5908       else
5909         # Check if the provided tool contains a complete path.
5910         tool_specified="$COMM"
5911         tool_basename="${tool_specified##*/}"
5912         if test "x$tool_basename" = "x$tool_specified"; then
5913           # A command without a complete path is provided, search $PATH.
5914           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool COMM=$tool_basename" >&5
5915 $as_echo "$as_me: Will search for user supplied tool COMM=$tool_basename" >&6;}
5916           # Extract the first word of "$tool_basename", so it can be a program name with args.
5917 set dummy $tool_basename; ac_word=$2
5918 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5919 $as_echo_n "checking for $ac_word... " >&6; }
5920 if ${ac_cv_path_COMM+:} false; then :
5921   $as_echo_n "(cached) " >&6
5922 else
5923   case $COMM in
5924   [\\/]* | ?:[\\/]*)
5925   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
5926   ;;
5927   *)
5928   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5929 for as_dir in $PATH
5930 do
5931   IFS=$as_save_IFS
5932   test -z "$as_dir" && as_dir=.
5933     for ac_exec_ext in '' $ac_executable_extensions; do
5934   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5935     ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
5936     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5937     break 2
5938   fi
5939 done
5940   done
5941 IFS=$as_save_IFS
5942 
5943   ;;
5944 esac
5945 fi
5946 COMM=$ac_cv_path_COMM
5947 if test -n "$COMM"; then
5948   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
5949 $as_echo "$COMM" >&6; }
5950 else
5951   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5952 $as_echo "no" >&6; }
5953 fi
5954 
5955 
5956           if test "x$COMM" = x; then
5957             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5958           fi
5959         else
5960           # Otherwise we believe it is a complete path. Use it as it is.
5961           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool COMM=$tool_specified" >&5
5962 $as_echo "$as_me: Will use user supplied tool COMM=$tool_specified" >&6;}
5963           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for COMM" >&5
5964 $as_echo_n "checking for COMM... " >&6; }
5965           if test ! -x "$tool_specified"; then
5966             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5967 $as_echo "not found" >&6; }
5968             as_fn_error $? "User supplied tool COMM=$tool_specified does not exist or is not executable" "$LINENO" 5
5969           fi
5970           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5971 $as_echo "$tool_specified" >&6; }
5972         fi
5973       fi
5974     fi
5975 
5976   fi
5977 
5978 
5979 
5980   if test "x$COMM" = x; then
5981     as_fn_error $? "Could not find required tool for COMM" "$LINENO" 5
5982   fi
5983 
5984 
5985 
5986 
5987 
5988   # Publish this variable in the help.
5989 
5990 
5991   if [ -z "${CP+x}" ]; then
5992     # The variable is not set by user, try to locate tool using the code snippet
5993     for ac_prog in cp
5994 do
5995   # Extract the first word of "$ac_prog", so it can be a program name with args.
5996 set dummy $ac_prog; ac_word=$2
5997 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5998 $as_echo_n "checking for $ac_word... " >&6; }
5999 if ${ac_cv_path_CP+:} false; then :
6000   $as_echo_n "(cached) " >&6
6001 else
6002   case $CP in
6003   [\\/]* | ?:[\\/]*)
6004   ac_cv_path_CP="$CP" # Let the user override the test with a path.
6005   ;;
6006   *)
6007   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6008 for as_dir in $PATH
6009 do
6010   IFS=$as_save_IFS
6011   test -z "$as_dir" && as_dir=.
6012     for ac_exec_ext in '' $ac_executable_extensions; do
6013   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6014     ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
6015     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6016     break 2
6017   fi
6018 done
6019   done
6020 IFS=$as_save_IFS
6021 
6022   ;;
6023 esac
6024 fi
6025 CP=$ac_cv_path_CP
6026 if test -n "$CP"; then
6027   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
6028 $as_echo "$CP" >&6; }
6029 else
6030   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6031 $as_echo "no" >&6; }
6032 fi
6033 
6034 
6035   test -n "$CP" && break
6036 done
6037 
6038   else
6039     # The variable is set, but is it from the command line or the environment?
6040 
6041     # Try to remove the string !CP! from our list.
6042     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CP!/}
6043     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6044       # If it failed, the variable was not from the command line. Ignore it,
6045       # but warn the user (except for BASH, which is always set by the calling BASH).
6046       if test "xCP" != xBASH; then
6047         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CP from the environment. Use command line variables instead." >&5
6048 $as_echo "$as_me: WARNING: Ignoring value of CP from the environment. Use command line variables instead." >&2;}
6049       fi
6050       # Try to locate tool using the code snippet
6051       for ac_prog in cp
6052 do
6053   # Extract the first word of "$ac_prog", so it can be a program name with args.
6054 set dummy $ac_prog; ac_word=$2
6055 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6056 $as_echo_n "checking for $ac_word... " >&6; }
6057 if ${ac_cv_path_CP+:} false; then :
6058   $as_echo_n "(cached) " >&6
6059 else
6060   case $CP in
6061   [\\/]* | ?:[\\/]*)
6062   ac_cv_path_CP="$CP" # Let the user override the test with a path.
6063   ;;
6064   *)
6065   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6066 for as_dir in $PATH
6067 do
6068   IFS=$as_save_IFS
6069   test -z "$as_dir" && as_dir=.
6070     for ac_exec_ext in '' $ac_executable_extensions; do
6071   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6072     ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
6073     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6074     break 2
6075   fi
6076 done
6077   done
6078 IFS=$as_save_IFS
6079 
6080   ;;
6081 esac
6082 fi
6083 CP=$ac_cv_path_CP
6084 if test -n "$CP"; then
6085   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
6086 $as_echo "$CP" >&6; }
6087 else
6088   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6089 $as_echo "no" >&6; }
6090 fi
6091 
6092 
6093   test -n "$CP" && break
6094 done
6095 
6096     else
6097       # If it succeeded, then it was overridden by the user. We will use it
6098       # for the tool.
6099 
6100       # First remove it from the list of overridden variables, so we can test
6101       # for unknown variables in the end.
6102       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6103 
6104       # Check if we try to supply an empty value
6105       if test "x$CP" = x; then
6106         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CP= (no value)" >&5
6107 $as_echo "$as_me: Setting user supplied tool CP= (no value)" >&6;}
6108         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CP" >&5
6109 $as_echo_n "checking for CP... " >&6; }
6110         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
6111 $as_echo "disabled" >&6; }
6112       else
6113         # Check if the provided tool contains a complete path.
6114         tool_specified="$CP"
6115         tool_basename="${tool_specified##*/}"
6116         if test "x$tool_basename" = "x$tool_specified"; then
6117           # A command without a complete path is provided, search $PATH.
6118           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CP=$tool_basename" >&5
6119 $as_echo "$as_me: Will search for user supplied tool CP=$tool_basename" >&6;}
6120           # Extract the first word of "$tool_basename", so it can be a program name with args.
6121 set dummy $tool_basename; ac_word=$2
6122 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6123 $as_echo_n "checking for $ac_word... " >&6; }
6124 if ${ac_cv_path_CP+:} false; then :
6125   $as_echo_n "(cached) " >&6
6126 else
6127   case $CP in
6128   [\\/]* | ?:[\\/]*)
6129   ac_cv_path_CP="$CP" # Let the user override the test with a path.
6130   ;;
6131   *)
6132   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6133 for as_dir in $PATH
6134 do
6135   IFS=$as_save_IFS
6136   test -z "$as_dir" && as_dir=.
6137     for ac_exec_ext in '' $ac_executable_extensions; do
6138   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6139     ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
6140     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6141     break 2
6142   fi
6143 done
6144   done
6145 IFS=$as_save_IFS
6146 
6147   ;;
6148 esac
6149 fi
6150 CP=$ac_cv_path_CP
6151 if test -n "$CP"; then
6152   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
6153 $as_echo "$CP" >&6; }
6154 else
6155   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6156 $as_echo "no" >&6; }
6157 fi
6158 
6159 
6160           if test "x$CP" = x; then
6161             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6162           fi
6163         else
6164           # Otherwise we believe it is a complete path. Use it as it is.
6165           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CP=$tool_specified" >&5
6166 $as_echo "$as_me: Will use user supplied tool CP=$tool_specified" >&6;}
6167           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CP" >&5
6168 $as_echo_n "checking for CP... " >&6; }
6169           if test ! -x "$tool_specified"; then
6170             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6171 $as_echo "not found" >&6; }
6172             as_fn_error $? "User supplied tool CP=$tool_specified does not exist or is not executable" "$LINENO" 5
6173           fi
6174           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6175 $as_echo "$tool_specified" >&6; }
6176         fi
6177       fi
6178     fi
6179 
6180   fi
6181 
6182 
6183 
6184   if test "x$CP" = x; then
6185     as_fn_error $? "Could not find required tool for CP" "$LINENO" 5
6186   fi
6187 
6188 
6189 
6190 
6191 
6192   # Publish this variable in the help.
6193 
6194 
6195   if [ -z "${CUT+x}" ]; then
6196     # The variable is not set by user, try to locate tool using the code snippet
6197     for ac_prog in cut
6198 do
6199   # Extract the first word of "$ac_prog", so it can be a program name with args.
6200 set dummy $ac_prog; ac_word=$2
6201 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6202 $as_echo_n "checking for $ac_word... " >&6; }
6203 if ${ac_cv_path_CUT+:} false; then :
6204   $as_echo_n "(cached) " >&6
6205 else
6206   case $CUT in
6207   [\\/]* | ?:[\\/]*)
6208   ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
6209   ;;
6210   *)
6211   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6212 for as_dir in $PATH
6213 do
6214   IFS=$as_save_IFS
6215   test -z "$as_dir" && as_dir=.
6216     for ac_exec_ext in '' $ac_executable_extensions; do
6217   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6218     ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
6219     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6220     break 2
6221   fi
6222 done
6223   done
6224 IFS=$as_save_IFS
6225 
6226   ;;
6227 esac
6228 fi
6229 CUT=$ac_cv_path_CUT
6230 if test -n "$CUT"; then
6231   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
6232 $as_echo "$CUT" >&6; }
6233 else
6234   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6235 $as_echo "no" >&6; }
6236 fi
6237 
6238 
6239   test -n "$CUT" && break
6240 done
6241 
6242   else
6243     # The variable is set, but is it from the command line or the environment?
6244 
6245     # Try to remove the string !CUT! from our list.
6246     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CUT!/}
6247     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6248       # If it failed, the variable was not from the command line. Ignore it,
6249       # but warn the user (except for BASH, which is always set by the calling BASH).
6250       if test "xCUT" != xBASH; then
6251         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CUT from the environment. Use command line variables instead." >&5
6252 $as_echo "$as_me: WARNING: Ignoring value of CUT from the environment. Use command line variables instead." >&2;}
6253       fi
6254       # Try to locate tool using the code snippet
6255       for ac_prog in cut
6256 do
6257   # Extract the first word of "$ac_prog", so it can be a program name with args.
6258 set dummy $ac_prog; ac_word=$2
6259 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6260 $as_echo_n "checking for $ac_word... " >&6; }
6261 if ${ac_cv_path_CUT+:} false; then :
6262   $as_echo_n "(cached) " >&6
6263 else
6264   case $CUT in
6265   [\\/]* | ?:[\\/]*)
6266   ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
6267   ;;
6268   *)
6269   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6270 for as_dir in $PATH
6271 do
6272   IFS=$as_save_IFS
6273   test -z "$as_dir" && as_dir=.
6274     for ac_exec_ext in '' $ac_executable_extensions; do
6275   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6276     ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
6277     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6278     break 2
6279   fi
6280 done
6281   done
6282 IFS=$as_save_IFS
6283 
6284   ;;
6285 esac
6286 fi
6287 CUT=$ac_cv_path_CUT
6288 if test -n "$CUT"; then
6289   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
6290 $as_echo "$CUT" >&6; }
6291 else
6292   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6293 $as_echo "no" >&6; }
6294 fi
6295 
6296 
6297   test -n "$CUT" && break
6298 done
6299 
6300     else
6301       # If it succeeded, then it was overridden by the user. We will use it
6302       # for the tool.
6303 
6304       # First remove it from the list of overridden variables, so we can test
6305       # for unknown variables in the end.
6306       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6307 
6308       # Check if we try to supply an empty value
6309       if test "x$CUT" = x; then
6310         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CUT= (no value)" >&5
6311 $as_echo "$as_me: Setting user supplied tool CUT= (no value)" >&6;}
6312         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CUT" >&5
6313 $as_echo_n "checking for CUT... " >&6; }
6314         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
6315 $as_echo "disabled" >&6; }
6316       else
6317         # Check if the provided tool contains a complete path.
6318         tool_specified="$CUT"
6319         tool_basename="${tool_specified##*/}"
6320         if test "x$tool_basename" = "x$tool_specified"; then
6321           # A command without a complete path is provided, search $PATH.
6322           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CUT=$tool_basename" >&5
6323 $as_echo "$as_me: Will search for user supplied tool CUT=$tool_basename" >&6;}
6324           # Extract the first word of "$tool_basename", so it can be a program name with args.
6325 set dummy $tool_basename; ac_word=$2
6326 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6327 $as_echo_n "checking for $ac_word... " >&6; }
6328 if ${ac_cv_path_CUT+:} false; then :
6329   $as_echo_n "(cached) " >&6
6330 else
6331   case $CUT in
6332   [\\/]* | ?:[\\/]*)
6333   ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
6334   ;;
6335   *)
6336   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6337 for as_dir in $PATH
6338 do
6339   IFS=$as_save_IFS
6340   test -z "$as_dir" && as_dir=.
6341     for ac_exec_ext in '' $ac_executable_extensions; do
6342   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6343     ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
6344     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6345     break 2
6346   fi
6347 done
6348   done
6349 IFS=$as_save_IFS
6350 
6351   ;;
6352 esac
6353 fi
6354 CUT=$ac_cv_path_CUT
6355 if test -n "$CUT"; then
6356   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
6357 $as_echo "$CUT" >&6; }
6358 else
6359   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6360 $as_echo "no" >&6; }
6361 fi
6362 
6363 
6364           if test "x$CUT" = x; then
6365             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6366           fi
6367         else
6368           # Otherwise we believe it is a complete path. Use it as it is.
6369           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CUT=$tool_specified" >&5
6370 $as_echo "$as_me: Will use user supplied tool CUT=$tool_specified" >&6;}
6371           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CUT" >&5
6372 $as_echo_n "checking for CUT... " >&6; }
6373           if test ! -x "$tool_specified"; then
6374             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6375 $as_echo "not found" >&6; }
6376             as_fn_error $? "User supplied tool CUT=$tool_specified does not exist or is not executable" "$LINENO" 5
6377           fi
6378           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6379 $as_echo "$tool_specified" >&6; }
6380         fi
6381       fi
6382     fi
6383 
6384   fi
6385 
6386 
6387 
6388   if test "x$CUT" = x; then
6389     as_fn_error $? "Could not find required tool for CUT" "$LINENO" 5
6390   fi
6391 
6392 
6393 
6394 
6395 
6396   # Publish this variable in the help.
6397 
6398 
6399   if [ -z "${DATE+x}" ]; then
6400     # The variable is not set by user, try to locate tool using the code snippet
6401     for ac_prog in date
6402 do
6403   # Extract the first word of "$ac_prog", so it can be a program name with args.
6404 set dummy $ac_prog; ac_word=$2
6405 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6406 $as_echo_n "checking for $ac_word... " >&6; }
6407 if ${ac_cv_path_DATE+:} false; then :
6408   $as_echo_n "(cached) " >&6
6409 else
6410   case $DATE in
6411   [\\/]* | ?:[\\/]*)
6412   ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
6413   ;;
6414   *)
6415   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6416 for as_dir in $PATH
6417 do
6418   IFS=$as_save_IFS
6419   test -z "$as_dir" && as_dir=.
6420     for ac_exec_ext in '' $ac_executable_extensions; do
6421   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6422     ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
6423     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6424     break 2
6425   fi
6426 done
6427   done
6428 IFS=$as_save_IFS
6429 
6430   ;;
6431 esac
6432 fi
6433 DATE=$ac_cv_path_DATE
6434 if test -n "$DATE"; then
6435   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
6436 $as_echo "$DATE" >&6; }
6437 else
6438   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6439 $as_echo "no" >&6; }
6440 fi
6441 
6442 
6443   test -n "$DATE" && break
6444 done
6445 
6446   else
6447     # The variable is set, but is it from the command line or the environment?
6448 
6449     # Try to remove the string !DATE! from our list.
6450     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DATE!/}
6451     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6452       # If it failed, the variable was not from the command line. Ignore it,
6453       # but warn the user (except for BASH, which is always set by the calling BASH).
6454       if test "xDATE" != xBASH; then
6455         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DATE from the environment. Use command line variables instead." >&5
6456 $as_echo "$as_me: WARNING: Ignoring value of DATE from the environment. Use command line variables instead." >&2;}
6457       fi
6458       # Try to locate tool using the code snippet
6459       for ac_prog in date
6460 do
6461   # Extract the first word of "$ac_prog", so it can be a program name with args.
6462 set dummy $ac_prog; ac_word=$2
6463 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6464 $as_echo_n "checking for $ac_word... " >&6; }
6465 if ${ac_cv_path_DATE+:} false; then :
6466   $as_echo_n "(cached) " >&6
6467 else
6468   case $DATE in
6469   [\\/]* | ?:[\\/]*)
6470   ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
6471   ;;
6472   *)
6473   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6474 for as_dir in $PATH
6475 do
6476   IFS=$as_save_IFS
6477   test -z "$as_dir" && as_dir=.
6478     for ac_exec_ext in '' $ac_executable_extensions; do
6479   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6480     ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
6481     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6482     break 2
6483   fi
6484 done
6485   done
6486 IFS=$as_save_IFS
6487 
6488   ;;
6489 esac
6490 fi
6491 DATE=$ac_cv_path_DATE
6492 if test -n "$DATE"; then
6493   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
6494 $as_echo "$DATE" >&6; }
6495 else
6496   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6497 $as_echo "no" >&6; }
6498 fi
6499 
6500 
6501   test -n "$DATE" && break
6502 done
6503 
6504     else
6505       # If it succeeded, then it was overridden by the user. We will use it
6506       # for the tool.
6507 
6508       # First remove it from the list of overridden variables, so we can test
6509       # for unknown variables in the end.
6510       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6511 
6512       # Check if we try to supply an empty value
6513       if test "x$DATE" = x; then
6514         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool DATE= (no value)" >&5
6515 $as_echo "$as_me: Setting user supplied tool DATE= (no value)" >&6;}
6516         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DATE" >&5
6517 $as_echo_n "checking for DATE... " >&6; }
6518         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
6519 $as_echo "disabled" >&6; }
6520       else
6521         # Check if the provided tool contains a complete path.
6522         tool_specified="$DATE"
6523         tool_basename="${tool_specified##*/}"
6524         if test "x$tool_basename" = "x$tool_specified"; then
6525           # A command without a complete path is provided, search $PATH.
6526           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DATE=$tool_basename" >&5
6527 $as_echo "$as_me: Will search for user supplied tool DATE=$tool_basename" >&6;}
6528           # Extract the first word of "$tool_basename", so it can be a program name with args.
6529 set dummy $tool_basename; ac_word=$2
6530 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6531 $as_echo_n "checking for $ac_word... " >&6; }
6532 if ${ac_cv_path_DATE+:} false; then :
6533   $as_echo_n "(cached) " >&6
6534 else
6535   case $DATE in
6536   [\\/]* | ?:[\\/]*)
6537   ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
6538   ;;
6539   *)
6540   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6541 for as_dir in $PATH
6542 do
6543   IFS=$as_save_IFS
6544   test -z "$as_dir" && as_dir=.
6545     for ac_exec_ext in '' $ac_executable_extensions; do
6546   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6547     ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
6548     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6549     break 2
6550   fi
6551 done
6552   done
6553 IFS=$as_save_IFS
6554 
6555   ;;
6556 esac
6557 fi
6558 DATE=$ac_cv_path_DATE
6559 if test -n "$DATE"; then
6560   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
6561 $as_echo "$DATE" >&6; }
6562 else
6563   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6564 $as_echo "no" >&6; }
6565 fi
6566 
6567 
6568           if test "x$DATE" = x; then
6569             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6570           fi
6571         else
6572           # Otherwise we believe it is a complete path. Use it as it is.
6573           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DATE=$tool_specified" >&5
6574 $as_echo "$as_me: Will use user supplied tool DATE=$tool_specified" >&6;}
6575           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DATE" >&5
6576 $as_echo_n "checking for DATE... " >&6; }
6577           if test ! -x "$tool_specified"; then
6578             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6579 $as_echo "not found" >&6; }
6580             as_fn_error $? "User supplied tool DATE=$tool_specified does not exist or is not executable" "$LINENO" 5
6581           fi
6582           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6583 $as_echo "$tool_specified" >&6; }
6584         fi
6585       fi
6586     fi
6587 
6588   fi
6589 
6590 
6591 
6592   if test "x$DATE" = x; then
6593     as_fn_error $? "Could not find required tool for DATE" "$LINENO" 5
6594   fi
6595 
6596 
6597 
6598 
6599 
6600   # Publish this variable in the help.
6601 
6602 
6603   if [ -z "${DIFF+x}" ]; then
6604     # The variable is not set by user, try to locate tool using the code snippet
6605     for ac_prog in gdiff diff
6606 do
6607   # Extract the first word of "$ac_prog", so it can be a program name with args.
6608 set dummy $ac_prog; ac_word=$2
6609 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6610 $as_echo_n "checking for $ac_word... " >&6; }
6611 if ${ac_cv_path_DIFF+:} false; then :
6612   $as_echo_n "(cached) " >&6
6613 else
6614   case $DIFF in
6615   [\\/]* | ?:[\\/]*)
6616   ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
6617   ;;
6618   *)
6619   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6620 for as_dir in $PATH
6621 do
6622   IFS=$as_save_IFS
6623   test -z "$as_dir" && as_dir=.
6624     for ac_exec_ext in '' $ac_executable_extensions; do
6625   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6626     ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
6627     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6628     break 2
6629   fi
6630 done
6631   done
6632 IFS=$as_save_IFS
6633 
6634   ;;
6635 esac
6636 fi
6637 DIFF=$ac_cv_path_DIFF
6638 if test -n "$DIFF"; then
6639   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
6640 $as_echo "$DIFF" >&6; }
6641 else
6642   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6643 $as_echo "no" >&6; }
6644 fi
6645 
6646 
6647   test -n "$DIFF" && break
6648 done
6649 
6650   else
6651     # The variable is set, but is it from the command line or the environment?
6652 
6653     # Try to remove the string !DIFF! from our list.
6654     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DIFF!/}
6655     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6656       # If it failed, the variable was not from the command line. Ignore it,
6657       # but warn the user (except for BASH, which is always set by the calling BASH).
6658       if test "xDIFF" != xBASH; then
6659         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DIFF from the environment. Use command line variables instead." >&5
6660 $as_echo "$as_me: WARNING: Ignoring value of DIFF from the environment. Use command line variables instead." >&2;}
6661       fi
6662       # Try to locate tool using the code snippet
6663       for ac_prog in gdiff diff
6664 do
6665   # Extract the first word of "$ac_prog", so it can be a program name with args.
6666 set dummy $ac_prog; ac_word=$2
6667 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6668 $as_echo_n "checking for $ac_word... " >&6; }
6669 if ${ac_cv_path_DIFF+:} false; then :
6670   $as_echo_n "(cached) " >&6
6671 else
6672   case $DIFF in
6673   [\\/]* | ?:[\\/]*)
6674   ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
6675   ;;
6676   *)
6677   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6678 for as_dir in $PATH
6679 do
6680   IFS=$as_save_IFS
6681   test -z "$as_dir" && as_dir=.
6682     for ac_exec_ext in '' $ac_executable_extensions; do
6683   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6684     ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
6685     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6686     break 2
6687   fi
6688 done
6689   done
6690 IFS=$as_save_IFS
6691 
6692   ;;
6693 esac
6694 fi
6695 DIFF=$ac_cv_path_DIFF
6696 if test -n "$DIFF"; then
6697   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
6698 $as_echo "$DIFF" >&6; }
6699 else
6700   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6701 $as_echo "no" >&6; }
6702 fi
6703 
6704 
6705   test -n "$DIFF" && break
6706 done
6707 
6708     else
6709       # If it succeeded, then it was overridden by the user. We will use it
6710       # for the tool.
6711 
6712       # First remove it from the list of overridden variables, so we can test
6713       # for unknown variables in the end.
6714       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6715 
6716       # Check if we try to supply an empty value
6717       if test "x$DIFF" = x; then
6718         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool DIFF= (no value)" >&5
6719 $as_echo "$as_me: Setting user supplied tool DIFF= (no value)" >&6;}
6720         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIFF" >&5
6721 $as_echo_n "checking for DIFF... " >&6; }
6722         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
6723 $as_echo "disabled" >&6; }
6724       else
6725         # Check if the provided tool contains a complete path.
6726         tool_specified="$DIFF"
6727         tool_basename="${tool_specified##*/}"
6728         if test "x$tool_basename" = "x$tool_specified"; then
6729           # A command without a complete path is provided, search $PATH.
6730           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DIFF=$tool_basename" >&5
6731 $as_echo "$as_me: Will search for user supplied tool DIFF=$tool_basename" >&6;}
6732           # Extract the first word of "$tool_basename", so it can be a program name with args.
6733 set dummy $tool_basename; ac_word=$2
6734 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6735 $as_echo_n "checking for $ac_word... " >&6; }
6736 if ${ac_cv_path_DIFF+:} false; then :
6737   $as_echo_n "(cached) " >&6
6738 else
6739   case $DIFF in
6740   [\\/]* | ?:[\\/]*)
6741   ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
6742   ;;
6743   *)
6744   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6745 for as_dir in $PATH
6746 do
6747   IFS=$as_save_IFS
6748   test -z "$as_dir" && as_dir=.
6749     for ac_exec_ext in '' $ac_executable_extensions; do
6750   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6751     ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
6752     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6753     break 2
6754   fi
6755 done
6756   done
6757 IFS=$as_save_IFS
6758 
6759   ;;
6760 esac
6761 fi
6762 DIFF=$ac_cv_path_DIFF
6763 if test -n "$DIFF"; then
6764   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
6765 $as_echo "$DIFF" >&6; }
6766 else
6767   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6768 $as_echo "no" >&6; }
6769 fi
6770 
6771 
6772           if test "x$DIFF" = x; then
6773             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6774           fi
6775         else
6776           # Otherwise we believe it is a complete path. Use it as it is.
6777           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DIFF=$tool_specified" >&5
6778 $as_echo "$as_me: Will use user supplied tool DIFF=$tool_specified" >&6;}
6779           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIFF" >&5
6780 $as_echo_n "checking for DIFF... " >&6; }
6781           if test ! -x "$tool_specified"; then
6782             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6783 $as_echo "not found" >&6; }
6784             as_fn_error $? "User supplied tool DIFF=$tool_specified does not exist or is not executable" "$LINENO" 5
6785           fi
6786           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6787 $as_echo "$tool_specified" >&6; }
6788         fi
6789       fi
6790     fi
6791 
6792   fi
6793 
6794 
6795 
6796   if test "x$DIFF" = x; then
6797     as_fn_error $? "Could not find required tool for DIFF" "$LINENO" 5
6798   fi
6799 
6800 
6801 
6802 
6803 
6804   # Publish this variable in the help.
6805 
6806 
6807   if [ -z "${DIRNAME+x}" ]; then
6808     # The variable is not set by user, try to locate tool using the code snippet
6809     for ac_prog in dirname
6810 do
6811   # Extract the first word of "$ac_prog", so it can be a program name with args.
6812 set dummy $ac_prog; ac_word=$2
6813 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6814 $as_echo_n "checking for $ac_word... " >&6; }
6815 if ${ac_cv_path_DIRNAME+:} false; then :
6816   $as_echo_n "(cached) " >&6
6817 else
6818   case $DIRNAME in
6819   [\\/]* | ?:[\\/]*)
6820   ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
6821   ;;
6822   *)
6823   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6824 for as_dir in $PATH
6825 do
6826   IFS=$as_save_IFS
6827   test -z "$as_dir" && as_dir=.
6828     for ac_exec_ext in '' $ac_executable_extensions; do
6829   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6830     ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
6831     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6832     break 2
6833   fi
6834 done
6835   done
6836 IFS=$as_save_IFS
6837 
6838   ;;
6839 esac
6840 fi
6841 DIRNAME=$ac_cv_path_DIRNAME
6842 if test -n "$DIRNAME"; then
6843   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
6844 $as_echo "$DIRNAME" >&6; }
6845 else
6846   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6847 $as_echo "no" >&6; }
6848 fi
6849 
6850 
6851   test -n "$DIRNAME" && break
6852 done
6853 
6854   else
6855     # The variable is set, but is it from the command line or the environment?
6856 
6857     # Try to remove the string !DIRNAME! from our list.
6858     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DIRNAME!/}
6859     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6860       # If it failed, the variable was not from the command line. Ignore it,
6861       # but warn the user (except for BASH, which is always set by the calling BASH).
6862       if test "xDIRNAME" != xBASH; then
6863         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DIRNAME from the environment. Use command line variables instead." >&5
6864 $as_echo "$as_me: WARNING: Ignoring value of DIRNAME from the environment. Use command line variables instead." >&2;}
6865       fi
6866       # Try to locate tool using the code snippet
6867       for ac_prog in dirname
6868 do
6869   # Extract the first word of "$ac_prog", so it can be a program name with args.
6870 set dummy $ac_prog; ac_word=$2
6871 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6872 $as_echo_n "checking for $ac_word... " >&6; }
6873 if ${ac_cv_path_DIRNAME+:} false; then :
6874   $as_echo_n "(cached) " >&6
6875 else
6876   case $DIRNAME in
6877   [\\/]* | ?:[\\/]*)
6878   ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
6879   ;;
6880   *)
6881   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6882 for as_dir in $PATH
6883 do
6884   IFS=$as_save_IFS
6885   test -z "$as_dir" && as_dir=.
6886     for ac_exec_ext in '' $ac_executable_extensions; do
6887   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6888     ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
6889     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6890     break 2
6891   fi
6892 done
6893   done
6894 IFS=$as_save_IFS
6895 
6896   ;;
6897 esac
6898 fi
6899 DIRNAME=$ac_cv_path_DIRNAME
6900 if test -n "$DIRNAME"; then
6901   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
6902 $as_echo "$DIRNAME" >&6; }
6903 else
6904   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6905 $as_echo "no" >&6; }
6906 fi
6907 
6908 
6909   test -n "$DIRNAME" && break
6910 done
6911 
6912     else
6913       # If it succeeded, then it was overridden by the user. We will use it
6914       # for the tool.
6915 
6916       # First remove it from the list of overridden variables, so we can test
6917       # for unknown variables in the end.
6918       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6919 
6920       # Check if we try to supply an empty value
6921       if test "x$DIRNAME" = x; then
6922         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool DIRNAME= (no value)" >&5
6923 $as_echo "$as_me: Setting user supplied tool DIRNAME= (no value)" >&6;}
6924         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIRNAME" >&5
6925 $as_echo_n "checking for DIRNAME... " >&6; }
6926         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
6927 $as_echo "disabled" >&6; }
6928       else
6929         # Check if the provided tool contains a complete path.
6930         tool_specified="$DIRNAME"
6931         tool_basename="${tool_specified##*/}"
6932         if test "x$tool_basename" = "x$tool_specified"; then
6933           # A command without a complete path is provided, search $PATH.
6934           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DIRNAME=$tool_basename" >&5
6935 $as_echo "$as_me: Will search for user supplied tool DIRNAME=$tool_basename" >&6;}
6936           # Extract the first word of "$tool_basename", so it can be a program name with args.
6937 set dummy $tool_basename; ac_word=$2
6938 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6939 $as_echo_n "checking for $ac_word... " >&6; }
6940 if ${ac_cv_path_DIRNAME+:} false; then :
6941   $as_echo_n "(cached) " >&6
6942 else
6943   case $DIRNAME in
6944   [\\/]* | ?:[\\/]*)
6945   ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
6946   ;;
6947   *)
6948   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6949 for as_dir in $PATH
6950 do
6951   IFS=$as_save_IFS
6952   test -z "$as_dir" && as_dir=.
6953     for ac_exec_ext in '' $ac_executable_extensions; do
6954   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6955     ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
6956     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6957     break 2
6958   fi
6959 done
6960   done
6961 IFS=$as_save_IFS
6962 
6963   ;;
6964 esac
6965 fi
6966 DIRNAME=$ac_cv_path_DIRNAME
6967 if test -n "$DIRNAME"; then
6968   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
6969 $as_echo "$DIRNAME" >&6; }
6970 else
6971   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6972 $as_echo "no" >&6; }
6973 fi
6974 
6975 
6976           if test "x$DIRNAME" = x; then
6977             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6978           fi
6979         else
6980           # Otherwise we believe it is a complete path. Use it as it is.
6981           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DIRNAME=$tool_specified" >&5
6982 $as_echo "$as_me: Will use user supplied tool DIRNAME=$tool_specified" >&6;}
6983           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIRNAME" >&5
6984 $as_echo_n "checking for DIRNAME... " >&6; }
6985           if test ! -x "$tool_specified"; then
6986             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6987 $as_echo "not found" >&6; }
6988             as_fn_error $? "User supplied tool DIRNAME=$tool_specified does not exist or is not executable" "$LINENO" 5
6989           fi
6990           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6991 $as_echo "$tool_specified" >&6; }
6992         fi
6993       fi
6994     fi
6995 
6996   fi
6997 
6998 
6999 
7000   if test "x$DIRNAME" = x; then
7001     as_fn_error $? "Could not find required tool for DIRNAME" "$LINENO" 5
7002   fi
7003 
7004 
7005 
7006 
7007 
7008   # Publish this variable in the help.
7009 
7010 
7011   if [ -z "${ECHO+x}" ]; then
7012     # The variable is not set by user, try to locate tool using the code snippet
7013     for ac_prog in echo
7014 do
7015   # Extract the first word of "$ac_prog", so it can be a program name with args.
7016 set dummy $ac_prog; ac_word=$2
7017 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7018 $as_echo_n "checking for $ac_word... " >&6; }
7019 if ${ac_cv_path_ECHO+:} false; then :
7020   $as_echo_n "(cached) " >&6
7021 else
7022   case $ECHO in
7023   [\\/]* | ?:[\\/]*)
7024   ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
7025   ;;
7026   *)
7027   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7028 for as_dir in $PATH
7029 do
7030   IFS=$as_save_IFS
7031   test -z "$as_dir" && as_dir=.
7032     for ac_exec_ext in '' $ac_executable_extensions; do
7033   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7034     ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
7035     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7036     break 2
7037   fi
7038 done
7039   done
7040 IFS=$as_save_IFS
7041 
7042   ;;
7043 esac
7044 fi
7045 ECHO=$ac_cv_path_ECHO
7046 if test -n "$ECHO"; then
7047   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
7048 $as_echo "$ECHO" >&6; }
7049 else
7050   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7051 $as_echo "no" >&6; }
7052 fi
7053 
7054 
7055   test -n "$ECHO" && break
7056 done
7057 
7058   else
7059     # The variable is set, but is it from the command line or the environment?
7060 
7061     # Try to remove the string !ECHO! from our list.
7062     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!ECHO!/}
7063     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7064       # If it failed, the variable was not from the command line. Ignore it,
7065       # but warn the user (except for BASH, which is always set by the calling BASH).
7066       if test "xECHO" != xBASH; then
7067         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ECHO from the environment. Use command line variables instead." >&5
7068 $as_echo "$as_me: WARNING: Ignoring value of ECHO from the environment. Use command line variables instead." >&2;}
7069       fi
7070       # Try to locate tool using the code snippet
7071       for ac_prog in echo
7072 do
7073   # Extract the first word of "$ac_prog", so it can be a program name with args.
7074 set dummy $ac_prog; ac_word=$2
7075 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7076 $as_echo_n "checking for $ac_word... " >&6; }
7077 if ${ac_cv_path_ECHO+:} false; then :
7078   $as_echo_n "(cached) " >&6
7079 else
7080   case $ECHO in
7081   [\\/]* | ?:[\\/]*)
7082   ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
7083   ;;
7084   *)
7085   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7086 for as_dir in $PATH
7087 do
7088   IFS=$as_save_IFS
7089   test -z "$as_dir" && as_dir=.
7090     for ac_exec_ext in '' $ac_executable_extensions; do
7091   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7092     ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
7093     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7094     break 2
7095   fi
7096 done
7097   done
7098 IFS=$as_save_IFS
7099 
7100   ;;
7101 esac
7102 fi
7103 ECHO=$ac_cv_path_ECHO
7104 if test -n "$ECHO"; then
7105   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
7106 $as_echo "$ECHO" >&6; }
7107 else
7108   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7109 $as_echo "no" >&6; }
7110 fi
7111 
7112 
7113   test -n "$ECHO" && break
7114 done
7115 
7116     else
7117       # If it succeeded, then it was overridden by the user. We will use it
7118       # for the tool.
7119 
7120       # First remove it from the list of overridden variables, so we can test
7121       # for unknown variables in the end.
7122       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7123 
7124       # Check if we try to supply an empty value
7125       if test "x$ECHO" = x; then
7126         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool ECHO= (no value)" >&5
7127 $as_echo "$as_me: Setting user supplied tool ECHO= (no value)" >&6;}
7128         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ECHO" >&5
7129 $as_echo_n "checking for ECHO... " >&6; }
7130         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
7131 $as_echo "disabled" >&6; }
7132       else
7133         # Check if the provided tool contains a complete path.
7134         tool_specified="$ECHO"
7135         tool_basename="${tool_specified##*/}"
7136         if test "x$tool_basename" = "x$tool_specified"; then
7137           # A command without a complete path is provided, search $PATH.
7138           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ECHO=$tool_basename" >&5
7139 $as_echo "$as_me: Will search for user supplied tool ECHO=$tool_basename" >&6;}
7140           # Extract the first word of "$tool_basename", so it can be a program name with args.
7141 set dummy $tool_basename; ac_word=$2
7142 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7143 $as_echo_n "checking for $ac_word... " >&6; }
7144 if ${ac_cv_path_ECHO+:} false; then :
7145   $as_echo_n "(cached) " >&6
7146 else
7147   case $ECHO in
7148   [\\/]* | ?:[\\/]*)
7149   ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
7150   ;;
7151   *)
7152   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7153 for as_dir in $PATH
7154 do
7155   IFS=$as_save_IFS
7156   test -z "$as_dir" && as_dir=.
7157     for ac_exec_ext in '' $ac_executable_extensions; do
7158   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7159     ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
7160     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7161     break 2
7162   fi
7163 done
7164   done
7165 IFS=$as_save_IFS
7166 
7167   ;;
7168 esac
7169 fi
7170 ECHO=$ac_cv_path_ECHO
7171 if test -n "$ECHO"; then
7172   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
7173 $as_echo "$ECHO" >&6; }
7174 else
7175   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7176 $as_echo "no" >&6; }
7177 fi
7178 
7179 
7180           if test "x$ECHO" = x; then
7181             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7182           fi
7183         else
7184           # Otherwise we believe it is a complete path. Use it as it is.
7185           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ECHO=$tool_specified" >&5
7186 $as_echo "$as_me: Will use user supplied tool ECHO=$tool_specified" >&6;}
7187           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ECHO" >&5
7188 $as_echo_n "checking for ECHO... " >&6; }
7189           if test ! -x "$tool_specified"; then
7190             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7191 $as_echo "not found" >&6; }
7192             as_fn_error $? "User supplied tool ECHO=$tool_specified does not exist or is not executable" "$LINENO" 5
7193           fi
7194           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7195 $as_echo "$tool_specified" >&6; }
7196         fi
7197       fi
7198     fi
7199 
7200   fi
7201 
7202 
7203 
7204   if test "x$ECHO" = x; then
7205     as_fn_error $? "Could not find required tool for ECHO" "$LINENO" 5
7206   fi
7207 
7208 
7209 
7210 
7211 
7212   # Publish this variable in the help.
7213 
7214 
7215   if [ -z "${EXPR+x}" ]; then
7216     # The variable is not set by user, try to locate tool using the code snippet
7217     for ac_prog in expr
7218 do
7219   # Extract the first word of "$ac_prog", so it can be a program name with args.
7220 set dummy $ac_prog; ac_word=$2
7221 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7222 $as_echo_n "checking for $ac_word... " >&6; }
7223 if ${ac_cv_path_EXPR+:} false; then :
7224   $as_echo_n "(cached) " >&6
7225 else
7226   case $EXPR in
7227   [\\/]* | ?:[\\/]*)
7228   ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
7229   ;;
7230   *)
7231   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7232 for as_dir in $PATH
7233 do
7234   IFS=$as_save_IFS
7235   test -z "$as_dir" && as_dir=.
7236     for ac_exec_ext in '' $ac_executable_extensions; do
7237   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7238     ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
7239     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7240     break 2
7241   fi
7242 done
7243   done
7244 IFS=$as_save_IFS
7245 
7246   ;;
7247 esac
7248 fi
7249 EXPR=$ac_cv_path_EXPR
7250 if test -n "$EXPR"; then
7251   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
7252 $as_echo "$EXPR" >&6; }
7253 else
7254   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7255 $as_echo "no" >&6; }
7256 fi
7257 
7258 
7259   test -n "$EXPR" && break
7260 done
7261 
7262   else
7263     # The variable is set, but is it from the command line or the environment?
7264 
7265     # Try to remove the string !EXPR! from our list.
7266     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!EXPR!/}
7267     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7268       # If it failed, the variable was not from the command line. Ignore it,
7269       # but warn the user (except for BASH, which is always set by the calling BASH).
7270       if test "xEXPR" != xBASH; then
7271         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of EXPR from the environment. Use command line variables instead." >&5
7272 $as_echo "$as_me: WARNING: Ignoring value of EXPR from the environment. Use command line variables instead." >&2;}
7273       fi
7274       # Try to locate tool using the code snippet
7275       for ac_prog in expr
7276 do
7277   # Extract the first word of "$ac_prog", so it can be a program name with args.
7278 set dummy $ac_prog; ac_word=$2
7279 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7280 $as_echo_n "checking for $ac_word... " >&6; }
7281 if ${ac_cv_path_EXPR+:} false; then :
7282   $as_echo_n "(cached) " >&6
7283 else
7284   case $EXPR in
7285   [\\/]* | ?:[\\/]*)
7286   ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
7287   ;;
7288   *)
7289   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7290 for as_dir in $PATH
7291 do
7292   IFS=$as_save_IFS
7293   test -z "$as_dir" && as_dir=.
7294     for ac_exec_ext in '' $ac_executable_extensions; do
7295   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7296     ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
7297     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7298     break 2
7299   fi
7300 done
7301   done
7302 IFS=$as_save_IFS
7303 
7304   ;;
7305 esac
7306 fi
7307 EXPR=$ac_cv_path_EXPR
7308 if test -n "$EXPR"; then
7309   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
7310 $as_echo "$EXPR" >&6; }
7311 else
7312   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7313 $as_echo "no" >&6; }
7314 fi
7315 
7316 
7317   test -n "$EXPR" && break
7318 done
7319 
7320     else
7321       # If it succeeded, then it was overridden by the user. We will use it
7322       # for the tool.
7323 
7324       # First remove it from the list of overridden variables, so we can test
7325       # for unknown variables in the end.
7326       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7327 
7328       # Check if we try to supply an empty value
7329       if test "x$EXPR" = x; then
7330         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool EXPR= (no value)" >&5
7331 $as_echo "$as_me: Setting user supplied tool EXPR= (no value)" >&6;}
7332         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EXPR" >&5
7333 $as_echo_n "checking for EXPR... " >&6; }
7334         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
7335 $as_echo "disabled" >&6; }
7336       else
7337         # Check if the provided tool contains a complete path.
7338         tool_specified="$EXPR"
7339         tool_basename="${tool_specified##*/}"
7340         if test "x$tool_basename" = "x$tool_specified"; then
7341           # A command without a complete path is provided, search $PATH.
7342           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool EXPR=$tool_basename" >&5
7343 $as_echo "$as_me: Will search for user supplied tool EXPR=$tool_basename" >&6;}
7344           # Extract the first word of "$tool_basename", so it can be a program name with args.
7345 set dummy $tool_basename; ac_word=$2
7346 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7347 $as_echo_n "checking for $ac_word... " >&6; }
7348 if ${ac_cv_path_EXPR+:} false; then :
7349   $as_echo_n "(cached) " >&6
7350 else
7351   case $EXPR in
7352   [\\/]* | ?:[\\/]*)
7353   ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
7354   ;;
7355   *)
7356   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7357 for as_dir in $PATH
7358 do
7359   IFS=$as_save_IFS
7360   test -z "$as_dir" && as_dir=.
7361     for ac_exec_ext in '' $ac_executable_extensions; do
7362   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7363     ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
7364     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7365     break 2
7366   fi
7367 done
7368   done
7369 IFS=$as_save_IFS
7370 
7371   ;;
7372 esac
7373 fi
7374 EXPR=$ac_cv_path_EXPR
7375 if test -n "$EXPR"; then
7376   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
7377 $as_echo "$EXPR" >&6; }
7378 else
7379   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7380 $as_echo "no" >&6; }
7381 fi
7382 
7383 
7384           if test "x$EXPR" = x; then
7385             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7386           fi
7387         else
7388           # Otherwise we believe it is a complete path. Use it as it is.
7389           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool EXPR=$tool_specified" >&5
7390 $as_echo "$as_me: Will use user supplied tool EXPR=$tool_specified" >&6;}
7391           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EXPR" >&5
7392 $as_echo_n "checking for EXPR... " >&6; }
7393           if test ! -x "$tool_specified"; then
7394             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7395 $as_echo "not found" >&6; }
7396             as_fn_error $? "User supplied tool EXPR=$tool_specified does not exist or is not executable" "$LINENO" 5
7397           fi
7398           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7399 $as_echo "$tool_specified" >&6; }
7400         fi
7401       fi
7402     fi
7403 
7404   fi
7405 
7406 
7407 
7408   if test "x$EXPR" = x; then
7409     as_fn_error $? "Could not find required tool for EXPR" "$LINENO" 5
7410   fi
7411 
7412 
7413 
7414 
7415 
7416   # Publish this variable in the help.
7417 
7418 
7419   if [ -z "${FILE+x}" ]; then
7420     # The variable is not set by user, try to locate tool using the code snippet
7421     for ac_prog in file
7422 do
7423   # Extract the first word of "$ac_prog", so it can be a program name with args.
7424 set dummy $ac_prog; ac_word=$2
7425 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7426 $as_echo_n "checking for $ac_word... " >&6; }
7427 if ${ac_cv_path_FILE+:} false; then :
7428   $as_echo_n "(cached) " >&6
7429 else
7430   case $FILE in
7431   [\\/]* | ?:[\\/]*)
7432   ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
7433   ;;
7434   *)
7435   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7436 for as_dir in $PATH
7437 do
7438   IFS=$as_save_IFS
7439   test -z "$as_dir" && as_dir=.
7440     for ac_exec_ext in '' $ac_executable_extensions; do
7441   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7442     ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
7443     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7444     break 2
7445   fi
7446 done
7447   done
7448 IFS=$as_save_IFS
7449 
7450   ;;
7451 esac
7452 fi
7453 FILE=$ac_cv_path_FILE
7454 if test -n "$FILE"; then
7455   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
7456 $as_echo "$FILE" >&6; }
7457 else
7458   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7459 $as_echo "no" >&6; }
7460 fi
7461 
7462 
7463   test -n "$FILE" && break
7464 done
7465 
7466   else
7467     # The variable is set, but is it from the command line or the environment?
7468 
7469     # Try to remove the string !FILE! from our list.
7470     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FILE!/}
7471     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7472       # If it failed, the variable was not from the command line. Ignore it,
7473       # but warn the user (except for BASH, which is always set by the calling BASH).
7474       if test "xFILE" != xBASH; then
7475         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FILE from the environment. Use command line variables instead." >&5
7476 $as_echo "$as_me: WARNING: Ignoring value of FILE from the environment. Use command line variables instead." >&2;}
7477       fi
7478       # Try to locate tool using the code snippet
7479       for ac_prog in file
7480 do
7481   # Extract the first word of "$ac_prog", so it can be a program name with args.
7482 set dummy $ac_prog; ac_word=$2
7483 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7484 $as_echo_n "checking for $ac_word... " >&6; }
7485 if ${ac_cv_path_FILE+:} false; then :
7486   $as_echo_n "(cached) " >&6
7487 else
7488   case $FILE in
7489   [\\/]* | ?:[\\/]*)
7490   ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
7491   ;;
7492   *)
7493   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7494 for as_dir in $PATH
7495 do
7496   IFS=$as_save_IFS
7497   test -z "$as_dir" && as_dir=.
7498     for ac_exec_ext in '' $ac_executable_extensions; do
7499   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7500     ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
7501     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7502     break 2
7503   fi
7504 done
7505   done
7506 IFS=$as_save_IFS
7507 
7508   ;;
7509 esac
7510 fi
7511 FILE=$ac_cv_path_FILE
7512 if test -n "$FILE"; then
7513   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
7514 $as_echo "$FILE" >&6; }
7515 else
7516   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7517 $as_echo "no" >&6; }
7518 fi
7519 
7520 
7521   test -n "$FILE" && break
7522 done
7523 
7524     else
7525       # If it succeeded, then it was overridden by the user. We will use it
7526       # for the tool.
7527 
7528       # First remove it from the list of overridden variables, so we can test
7529       # for unknown variables in the end.
7530       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7531 
7532       # Check if we try to supply an empty value
7533       if test "x$FILE" = x; then
7534         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool FILE= (no value)" >&5
7535 $as_echo "$as_me: Setting user supplied tool FILE= (no value)" >&6;}
7536         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FILE" >&5
7537 $as_echo_n "checking for FILE... " >&6; }
7538         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
7539 $as_echo "disabled" >&6; }
7540       else
7541         # Check if the provided tool contains a complete path.
7542         tool_specified="$FILE"
7543         tool_basename="${tool_specified##*/}"
7544         if test "x$tool_basename" = "x$tool_specified"; then
7545           # A command without a complete path is provided, search $PATH.
7546           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FILE=$tool_basename" >&5
7547 $as_echo "$as_me: Will search for user supplied tool FILE=$tool_basename" >&6;}
7548           # Extract the first word of "$tool_basename", so it can be a program name with args.
7549 set dummy $tool_basename; ac_word=$2
7550 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7551 $as_echo_n "checking for $ac_word... " >&6; }
7552 if ${ac_cv_path_FILE+:} false; then :
7553   $as_echo_n "(cached) " >&6
7554 else
7555   case $FILE in
7556   [\\/]* | ?:[\\/]*)
7557   ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
7558   ;;
7559   *)
7560   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7561 for as_dir in $PATH
7562 do
7563   IFS=$as_save_IFS
7564   test -z "$as_dir" && as_dir=.
7565     for ac_exec_ext in '' $ac_executable_extensions; do
7566   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7567     ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
7568     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7569     break 2
7570   fi
7571 done
7572   done
7573 IFS=$as_save_IFS
7574 
7575   ;;
7576 esac
7577 fi
7578 FILE=$ac_cv_path_FILE
7579 if test -n "$FILE"; then
7580   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
7581 $as_echo "$FILE" >&6; }
7582 else
7583   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7584 $as_echo "no" >&6; }
7585 fi
7586 
7587 
7588           if test "x$FILE" = x; then
7589             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7590           fi
7591         else
7592           # Otherwise we believe it is a complete path. Use it as it is.
7593           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FILE=$tool_specified" >&5
7594 $as_echo "$as_me: Will use user supplied tool FILE=$tool_specified" >&6;}
7595           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FILE" >&5
7596 $as_echo_n "checking for FILE... " >&6; }
7597           if test ! -x "$tool_specified"; then
7598             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7599 $as_echo "not found" >&6; }
7600             as_fn_error $? "User supplied tool FILE=$tool_specified does not exist or is not executable" "$LINENO" 5
7601           fi
7602           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7603 $as_echo "$tool_specified" >&6; }
7604         fi
7605       fi
7606     fi
7607 
7608   fi
7609 
7610 
7611 
7612   if test "x$FILE" = x; then
7613     as_fn_error $? "Could not find required tool for FILE" "$LINENO" 5
7614   fi
7615 
7616 
7617 
7618 
7619 
7620   # Publish this variable in the help.
7621 
7622 
7623   if [ -z "${FIND+x}" ]; then
7624     # The variable is not set by user, try to locate tool using the code snippet
7625     for ac_prog in find
7626 do
7627   # Extract the first word of "$ac_prog", so it can be a program name with args.
7628 set dummy $ac_prog; ac_word=$2
7629 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7630 $as_echo_n "checking for $ac_word... " >&6; }
7631 if ${ac_cv_path_FIND+:} false; then :
7632   $as_echo_n "(cached) " >&6
7633 else
7634   case $FIND in
7635   [\\/]* | ?:[\\/]*)
7636   ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
7637   ;;
7638   *)
7639   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7640 for as_dir in $PATH
7641 do
7642   IFS=$as_save_IFS
7643   test -z "$as_dir" && as_dir=.
7644     for ac_exec_ext in '' $ac_executable_extensions; do
7645   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7646     ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
7647     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7648     break 2
7649   fi
7650 done
7651   done
7652 IFS=$as_save_IFS
7653 
7654   ;;
7655 esac
7656 fi
7657 FIND=$ac_cv_path_FIND
7658 if test -n "$FIND"; then
7659   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
7660 $as_echo "$FIND" >&6; }
7661 else
7662   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7663 $as_echo "no" >&6; }
7664 fi
7665 
7666 
7667   test -n "$FIND" && break
7668 done
7669 
7670   else
7671     # The variable is set, but is it from the command line or the environment?
7672 
7673     # Try to remove the string !FIND! from our list.
7674     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FIND!/}
7675     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7676       # If it failed, the variable was not from the command line. Ignore it,
7677       # but warn the user (except for BASH, which is always set by the calling BASH).
7678       if test "xFIND" != xBASH; then
7679         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FIND from the environment. Use command line variables instead." >&5
7680 $as_echo "$as_me: WARNING: Ignoring value of FIND from the environment. Use command line variables instead." >&2;}
7681       fi
7682       # Try to locate tool using the code snippet
7683       for ac_prog in find
7684 do
7685   # Extract the first word of "$ac_prog", so it can be a program name with args.
7686 set dummy $ac_prog; ac_word=$2
7687 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7688 $as_echo_n "checking for $ac_word... " >&6; }
7689 if ${ac_cv_path_FIND+:} false; then :
7690   $as_echo_n "(cached) " >&6
7691 else
7692   case $FIND in
7693   [\\/]* | ?:[\\/]*)
7694   ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
7695   ;;
7696   *)
7697   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7698 for as_dir in $PATH
7699 do
7700   IFS=$as_save_IFS
7701   test -z "$as_dir" && as_dir=.
7702     for ac_exec_ext in '' $ac_executable_extensions; do
7703   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7704     ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
7705     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7706     break 2
7707   fi
7708 done
7709   done
7710 IFS=$as_save_IFS
7711 
7712   ;;
7713 esac
7714 fi
7715 FIND=$ac_cv_path_FIND
7716 if test -n "$FIND"; then
7717   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
7718 $as_echo "$FIND" >&6; }
7719 else
7720   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7721 $as_echo "no" >&6; }
7722 fi
7723 
7724 
7725   test -n "$FIND" && break
7726 done
7727 
7728     else
7729       # If it succeeded, then it was overridden by the user. We will use it
7730       # for the tool.
7731 
7732       # First remove it from the list of overridden variables, so we can test
7733       # for unknown variables in the end.
7734       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7735 
7736       # Check if we try to supply an empty value
7737       if test "x$FIND" = x; then
7738         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool FIND= (no value)" >&5
7739 $as_echo "$as_me: Setting user supplied tool FIND= (no value)" >&6;}
7740         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FIND" >&5
7741 $as_echo_n "checking for FIND... " >&6; }
7742         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
7743 $as_echo "disabled" >&6; }
7744       else
7745         # Check if the provided tool contains a complete path.
7746         tool_specified="$FIND"
7747         tool_basename="${tool_specified##*/}"
7748         if test "x$tool_basename" = "x$tool_specified"; then
7749           # A command without a complete path is provided, search $PATH.
7750           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FIND=$tool_basename" >&5
7751 $as_echo "$as_me: Will search for user supplied tool FIND=$tool_basename" >&6;}
7752           # Extract the first word of "$tool_basename", so it can be a program name with args.
7753 set dummy $tool_basename; ac_word=$2
7754 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7755 $as_echo_n "checking for $ac_word... " >&6; }
7756 if ${ac_cv_path_FIND+:} false; then :
7757   $as_echo_n "(cached) " >&6
7758 else
7759   case $FIND in
7760   [\\/]* | ?:[\\/]*)
7761   ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
7762   ;;
7763   *)
7764   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7765 for as_dir in $PATH
7766 do
7767   IFS=$as_save_IFS
7768   test -z "$as_dir" && as_dir=.
7769     for ac_exec_ext in '' $ac_executable_extensions; do
7770   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7771     ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
7772     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7773     break 2
7774   fi
7775 done
7776   done
7777 IFS=$as_save_IFS
7778 
7779   ;;
7780 esac
7781 fi
7782 FIND=$ac_cv_path_FIND
7783 if test -n "$FIND"; then
7784   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
7785 $as_echo "$FIND" >&6; }
7786 else
7787   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7788 $as_echo "no" >&6; }
7789 fi
7790 
7791 
7792           if test "x$FIND" = x; then
7793             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7794           fi
7795         else
7796           # Otherwise we believe it is a complete path. Use it as it is.
7797           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FIND=$tool_specified" >&5
7798 $as_echo "$as_me: Will use user supplied tool FIND=$tool_specified" >&6;}
7799           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FIND" >&5
7800 $as_echo_n "checking for FIND... " >&6; }
7801           if test ! -x "$tool_specified"; then
7802             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7803 $as_echo "not found" >&6; }
7804             as_fn_error $? "User supplied tool FIND=$tool_specified does not exist or is not executable" "$LINENO" 5
7805           fi
7806           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7807 $as_echo "$tool_specified" >&6; }
7808         fi
7809       fi
7810     fi
7811 
7812   fi
7813 
7814 
7815 
7816   if test "x$FIND" = x; then
7817     as_fn_error $? "Could not find required tool for FIND" "$LINENO" 5
7818   fi
7819 
7820 
7821 
7822 
7823 
7824   # Publish this variable in the help.
7825 
7826 
7827   if [ -z "${HEAD+x}" ]; then
7828     # The variable is not set by user, try to locate tool using the code snippet
7829     for ac_prog in head
7830 do
7831   # Extract the first word of "$ac_prog", so it can be a program name with args.
7832 set dummy $ac_prog; ac_word=$2
7833 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7834 $as_echo_n "checking for $ac_word... " >&6; }
7835 if ${ac_cv_path_HEAD+:} false; then :
7836   $as_echo_n "(cached) " >&6
7837 else
7838   case $HEAD in
7839   [\\/]* | ?:[\\/]*)
7840   ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
7841   ;;
7842   *)
7843   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7844 for as_dir in $PATH
7845 do
7846   IFS=$as_save_IFS
7847   test -z "$as_dir" && as_dir=.
7848     for ac_exec_ext in '' $ac_executable_extensions; do
7849   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7850     ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
7851     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7852     break 2
7853   fi
7854 done
7855   done
7856 IFS=$as_save_IFS
7857 
7858   ;;
7859 esac
7860 fi
7861 HEAD=$ac_cv_path_HEAD
7862 if test -n "$HEAD"; then
7863   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
7864 $as_echo "$HEAD" >&6; }
7865 else
7866   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7867 $as_echo "no" >&6; }
7868 fi
7869 
7870 
7871   test -n "$HEAD" && break
7872 done
7873 
7874   else
7875     # The variable is set, but is it from the command line or the environment?
7876 
7877     # Try to remove the string !HEAD! from our list.
7878     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!HEAD!/}
7879     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7880       # If it failed, the variable was not from the command line. Ignore it,
7881       # but warn the user (except for BASH, which is always set by the calling BASH).
7882       if test "xHEAD" != xBASH; then
7883         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of HEAD from the environment. Use command line variables instead." >&5
7884 $as_echo "$as_me: WARNING: Ignoring value of HEAD from the environment. Use command line variables instead." >&2;}
7885       fi
7886       # Try to locate tool using the code snippet
7887       for ac_prog in head
7888 do
7889   # Extract the first word of "$ac_prog", so it can be a program name with args.
7890 set dummy $ac_prog; ac_word=$2
7891 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7892 $as_echo_n "checking for $ac_word... " >&6; }
7893 if ${ac_cv_path_HEAD+:} false; then :
7894   $as_echo_n "(cached) " >&6
7895 else
7896   case $HEAD in
7897   [\\/]* | ?:[\\/]*)
7898   ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
7899   ;;
7900   *)
7901   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7902 for as_dir in $PATH
7903 do
7904   IFS=$as_save_IFS
7905   test -z "$as_dir" && as_dir=.
7906     for ac_exec_ext in '' $ac_executable_extensions; do
7907   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7908     ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
7909     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7910     break 2
7911   fi
7912 done
7913   done
7914 IFS=$as_save_IFS
7915 
7916   ;;
7917 esac
7918 fi
7919 HEAD=$ac_cv_path_HEAD
7920 if test -n "$HEAD"; then
7921   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
7922 $as_echo "$HEAD" >&6; }
7923 else
7924   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7925 $as_echo "no" >&6; }
7926 fi
7927 
7928 
7929   test -n "$HEAD" && break
7930 done
7931 
7932     else
7933       # If it succeeded, then it was overridden by the user. We will use it
7934       # for the tool.
7935 
7936       # First remove it from the list of overridden variables, so we can test
7937       # for unknown variables in the end.
7938       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7939 
7940       # Check if we try to supply an empty value
7941       if test "x$HEAD" = x; then
7942         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool HEAD= (no value)" >&5
7943 $as_echo "$as_me: Setting user supplied tool HEAD= (no value)" >&6;}
7944         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HEAD" >&5
7945 $as_echo_n "checking for HEAD... " >&6; }
7946         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
7947 $as_echo "disabled" >&6; }
7948       else
7949         # Check if the provided tool contains a complete path.
7950         tool_specified="$HEAD"
7951         tool_basename="${tool_specified##*/}"
7952         if test "x$tool_basename" = "x$tool_specified"; then
7953           # A command without a complete path is provided, search $PATH.
7954           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool HEAD=$tool_basename" >&5
7955 $as_echo "$as_me: Will search for user supplied tool HEAD=$tool_basename" >&6;}
7956           # Extract the first word of "$tool_basename", so it can be a program name with args.
7957 set dummy $tool_basename; ac_word=$2
7958 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7959 $as_echo_n "checking for $ac_word... " >&6; }
7960 if ${ac_cv_path_HEAD+:} false; then :
7961   $as_echo_n "(cached) " >&6
7962 else
7963   case $HEAD in
7964   [\\/]* | ?:[\\/]*)
7965   ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
7966   ;;
7967   *)
7968   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7969 for as_dir in $PATH
7970 do
7971   IFS=$as_save_IFS
7972   test -z "$as_dir" && as_dir=.
7973     for ac_exec_ext in '' $ac_executable_extensions; do
7974   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7975     ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
7976     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7977     break 2
7978   fi
7979 done
7980   done
7981 IFS=$as_save_IFS
7982 
7983   ;;
7984 esac
7985 fi
7986 HEAD=$ac_cv_path_HEAD
7987 if test -n "$HEAD"; then
7988   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
7989 $as_echo "$HEAD" >&6; }
7990 else
7991   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7992 $as_echo "no" >&6; }
7993 fi
7994 
7995 
7996           if test "x$HEAD" = x; then
7997             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7998           fi
7999         else
8000           # Otherwise we believe it is a complete path. Use it as it is.
8001           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool HEAD=$tool_specified" >&5
8002 $as_echo "$as_me: Will use user supplied tool HEAD=$tool_specified" >&6;}
8003           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HEAD" >&5
8004 $as_echo_n "checking for HEAD... " >&6; }
8005           if test ! -x "$tool_specified"; then
8006             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8007 $as_echo "not found" >&6; }
8008             as_fn_error $? "User supplied tool HEAD=$tool_specified does not exist or is not executable" "$LINENO" 5
8009           fi
8010           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8011 $as_echo "$tool_specified" >&6; }
8012         fi
8013       fi
8014     fi
8015 
8016   fi
8017 
8018 
8019 
8020   if test "x$HEAD" = x; then
8021     as_fn_error $? "Could not find required tool for HEAD" "$LINENO" 5
8022   fi
8023 
8024 
8025 
8026 
8027 
8028   # Publish this variable in the help.
8029 
8030 
8031   if [ -z "${LN+x}" ]; then
8032     # The variable is not set by user, try to locate tool using the code snippet
8033     for ac_prog in ln
8034 do
8035   # Extract the first word of "$ac_prog", so it can be a program name with args.
8036 set dummy $ac_prog; ac_word=$2
8037 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8038 $as_echo_n "checking for $ac_word... " >&6; }
8039 if ${ac_cv_path_LN+:} false; then :
8040   $as_echo_n "(cached) " >&6
8041 else
8042   case $LN in
8043   [\\/]* | ?:[\\/]*)
8044   ac_cv_path_LN="$LN" # Let the user override the test with a path.
8045   ;;
8046   *)
8047   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8048 for as_dir in $PATH
8049 do
8050   IFS=$as_save_IFS
8051   test -z "$as_dir" && as_dir=.
8052     for ac_exec_ext in '' $ac_executable_extensions; do
8053   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8054     ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
8055     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8056     break 2
8057   fi
8058 done
8059   done
8060 IFS=$as_save_IFS
8061 
8062   ;;
8063 esac
8064 fi
8065 LN=$ac_cv_path_LN
8066 if test -n "$LN"; then
8067   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
8068 $as_echo "$LN" >&6; }
8069 else
8070   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8071 $as_echo "no" >&6; }
8072 fi
8073 
8074 
8075   test -n "$LN" && break
8076 done
8077 
8078   else
8079     # The variable is set, but is it from the command line or the environment?
8080 
8081     # Try to remove the string !LN! from our list.
8082     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LN!/}
8083     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8084       # If it failed, the variable was not from the command line. Ignore it,
8085       # but warn the user (except for BASH, which is always set by the calling BASH).
8086       if test "xLN" != xBASH; then
8087         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LN from the environment. Use command line variables instead." >&5
8088 $as_echo "$as_me: WARNING: Ignoring value of LN from the environment. Use command line variables instead." >&2;}
8089       fi
8090       # Try to locate tool using the code snippet
8091       for ac_prog in ln
8092 do
8093   # Extract the first word of "$ac_prog", so it can be a program name with args.
8094 set dummy $ac_prog; ac_word=$2
8095 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8096 $as_echo_n "checking for $ac_word... " >&6; }
8097 if ${ac_cv_path_LN+:} false; then :
8098   $as_echo_n "(cached) " >&6
8099 else
8100   case $LN in
8101   [\\/]* | ?:[\\/]*)
8102   ac_cv_path_LN="$LN" # Let the user override the test with a path.
8103   ;;
8104   *)
8105   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8106 for as_dir in $PATH
8107 do
8108   IFS=$as_save_IFS
8109   test -z "$as_dir" && as_dir=.
8110     for ac_exec_ext in '' $ac_executable_extensions; do
8111   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8112     ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
8113     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8114     break 2
8115   fi
8116 done
8117   done
8118 IFS=$as_save_IFS
8119 
8120   ;;
8121 esac
8122 fi
8123 LN=$ac_cv_path_LN
8124 if test -n "$LN"; then
8125   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
8126 $as_echo "$LN" >&6; }
8127 else
8128   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8129 $as_echo "no" >&6; }
8130 fi
8131 
8132 
8133   test -n "$LN" && break
8134 done
8135 
8136     else
8137       # If it succeeded, then it was overridden by the user. We will use it
8138       # for the tool.
8139 
8140       # First remove it from the list of overridden variables, so we can test
8141       # for unknown variables in the end.
8142       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8143 
8144       # Check if we try to supply an empty value
8145       if test "x$LN" = x; then
8146         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool LN= (no value)" >&5
8147 $as_echo "$as_me: Setting user supplied tool LN= (no value)" >&6;}
8148         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LN" >&5
8149 $as_echo_n "checking for LN... " >&6; }
8150         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
8151 $as_echo "disabled" >&6; }
8152       else
8153         # Check if the provided tool contains a complete path.
8154         tool_specified="$LN"
8155         tool_basename="${tool_specified##*/}"
8156         if test "x$tool_basename" = "x$tool_specified"; then
8157           # A command without a complete path is provided, search $PATH.
8158           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LN=$tool_basename" >&5
8159 $as_echo "$as_me: Will search for user supplied tool LN=$tool_basename" >&6;}
8160           # Extract the first word of "$tool_basename", so it can be a program name with args.
8161 set dummy $tool_basename; ac_word=$2
8162 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8163 $as_echo_n "checking for $ac_word... " >&6; }
8164 if ${ac_cv_path_LN+:} false; then :
8165   $as_echo_n "(cached) " >&6
8166 else
8167   case $LN in
8168   [\\/]* | ?:[\\/]*)
8169   ac_cv_path_LN="$LN" # Let the user override the test with a path.
8170   ;;
8171   *)
8172   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8173 for as_dir in $PATH
8174 do
8175   IFS=$as_save_IFS
8176   test -z "$as_dir" && as_dir=.
8177     for ac_exec_ext in '' $ac_executable_extensions; do
8178   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8179     ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
8180     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8181     break 2
8182   fi
8183 done
8184   done
8185 IFS=$as_save_IFS
8186 
8187   ;;
8188 esac
8189 fi
8190 LN=$ac_cv_path_LN
8191 if test -n "$LN"; then
8192   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
8193 $as_echo "$LN" >&6; }
8194 else
8195   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8196 $as_echo "no" >&6; }
8197 fi
8198 
8199 
8200           if test "x$LN" = x; then
8201             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8202           fi
8203         else
8204           # Otherwise we believe it is a complete path. Use it as it is.
8205           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LN=$tool_specified" >&5
8206 $as_echo "$as_me: Will use user supplied tool LN=$tool_specified" >&6;}
8207           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LN" >&5
8208 $as_echo_n "checking for LN... " >&6; }
8209           if test ! -x "$tool_specified"; then
8210             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8211 $as_echo "not found" >&6; }
8212             as_fn_error $? "User supplied tool LN=$tool_specified does not exist or is not executable" "$LINENO" 5
8213           fi
8214           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8215 $as_echo "$tool_specified" >&6; }
8216         fi
8217       fi
8218     fi
8219 
8220   fi
8221 
8222 
8223 
8224   if test "x$LN" = x; then
8225     as_fn_error $? "Could not find required tool for LN" "$LINENO" 5
8226   fi
8227 
8228 
8229 
8230 
8231 
8232   # Publish this variable in the help.
8233 
8234 
8235   if [ -z "${LS+x}" ]; then
8236     # The variable is not set by user, try to locate tool using the code snippet
8237     for ac_prog in ls
8238 do
8239   # Extract the first word of "$ac_prog", so it can be a program name with args.
8240 set dummy $ac_prog; ac_word=$2
8241 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8242 $as_echo_n "checking for $ac_word... " >&6; }
8243 if ${ac_cv_path_LS+:} false; then :
8244   $as_echo_n "(cached) " >&6
8245 else
8246   case $LS in
8247   [\\/]* | ?:[\\/]*)
8248   ac_cv_path_LS="$LS" # Let the user override the test with a path.
8249   ;;
8250   *)
8251   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8252 for as_dir in $PATH
8253 do
8254   IFS=$as_save_IFS
8255   test -z "$as_dir" && as_dir=.
8256     for ac_exec_ext in '' $ac_executable_extensions; do
8257   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8258     ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
8259     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8260     break 2
8261   fi
8262 done
8263   done
8264 IFS=$as_save_IFS
8265 
8266   ;;
8267 esac
8268 fi
8269 LS=$ac_cv_path_LS
8270 if test -n "$LS"; then
8271   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
8272 $as_echo "$LS" >&6; }
8273 else
8274   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8275 $as_echo "no" >&6; }
8276 fi
8277 
8278 
8279   test -n "$LS" && break
8280 done
8281 
8282   else
8283     # The variable is set, but is it from the command line or the environment?
8284 
8285     # Try to remove the string !LS! from our list.
8286     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LS!/}
8287     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8288       # If it failed, the variable was not from the command line. Ignore it,
8289       # but warn the user (except for BASH, which is always set by the calling BASH).
8290       if test "xLS" != xBASH; then
8291         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LS from the environment. Use command line variables instead." >&5
8292 $as_echo "$as_me: WARNING: Ignoring value of LS from the environment. Use command line variables instead." >&2;}
8293       fi
8294       # Try to locate tool using the code snippet
8295       for ac_prog in ls
8296 do
8297   # Extract the first word of "$ac_prog", so it can be a program name with args.
8298 set dummy $ac_prog; ac_word=$2
8299 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8300 $as_echo_n "checking for $ac_word... " >&6; }
8301 if ${ac_cv_path_LS+:} false; then :
8302   $as_echo_n "(cached) " >&6
8303 else
8304   case $LS in
8305   [\\/]* | ?:[\\/]*)
8306   ac_cv_path_LS="$LS" # Let the user override the test with a path.
8307   ;;
8308   *)
8309   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8310 for as_dir in $PATH
8311 do
8312   IFS=$as_save_IFS
8313   test -z "$as_dir" && as_dir=.
8314     for ac_exec_ext in '' $ac_executable_extensions; do
8315   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8316     ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
8317     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8318     break 2
8319   fi
8320 done
8321   done
8322 IFS=$as_save_IFS
8323 
8324   ;;
8325 esac
8326 fi
8327 LS=$ac_cv_path_LS
8328 if test -n "$LS"; then
8329   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
8330 $as_echo "$LS" >&6; }
8331 else
8332   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8333 $as_echo "no" >&6; }
8334 fi
8335 
8336 
8337   test -n "$LS" && break
8338 done
8339 
8340     else
8341       # If it succeeded, then it was overridden by the user. We will use it
8342       # for the tool.
8343 
8344       # First remove it from the list of overridden variables, so we can test
8345       # for unknown variables in the end.
8346       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8347 
8348       # Check if we try to supply an empty value
8349       if test "x$LS" = x; then
8350         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool LS= (no value)" >&5
8351 $as_echo "$as_me: Setting user supplied tool LS= (no value)" >&6;}
8352         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LS" >&5
8353 $as_echo_n "checking for LS... " >&6; }
8354         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
8355 $as_echo "disabled" >&6; }
8356       else
8357         # Check if the provided tool contains a complete path.
8358         tool_specified="$LS"
8359         tool_basename="${tool_specified##*/}"
8360         if test "x$tool_basename" = "x$tool_specified"; then
8361           # A command without a complete path is provided, search $PATH.
8362           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LS=$tool_basename" >&5
8363 $as_echo "$as_me: Will search for user supplied tool LS=$tool_basename" >&6;}
8364           # Extract the first word of "$tool_basename", so it can be a program name with args.
8365 set dummy $tool_basename; ac_word=$2
8366 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8367 $as_echo_n "checking for $ac_word... " >&6; }
8368 if ${ac_cv_path_LS+:} false; then :
8369   $as_echo_n "(cached) " >&6
8370 else
8371   case $LS in
8372   [\\/]* | ?:[\\/]*)
8373   ac_cv_path_LS="$LS" # Let the user override the test with a path.
8374   ;;
8375   *)
8376   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8377 for as_dir in $PATH
8378 do
8379   IFS=$as_save_IFS
8380   test -z "$as_dir" && as_dir=.
8381     for ac_exec_ext in '' $ac_executable_extensions; do
8382   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8383     ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
8384     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8385     break 2
8386   fi
8387 done
8388   done
8389 IFS=$as_save_IFS
8390 
8391   ;;
8392 esac
8393 fi
8394 LS=$ac_cv_path_LS
8395 if test -n "$LS"; then
8396   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
8397 $as_echo "$LS" >&6; }
8398 else
8399   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8400 $as_echo "no" >&6; }
8401 fi
8402 
8403 
8404           if test "x$LS" = x; then
8405             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8406           fi
8407         else
8408           # Otherwise we believe it is a complete path. Use it as it is.
8409           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LS=$tool_specified" >&5
8410 $as_echo "$as_me: Will use user supplied tool LS=$tool_specified" >&6;}
8411           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LS" >&5
8412 $as_echo_n "checking for LS... " >&6; }
8413           if test ! -x "$tool_specified"; then
8414             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8415 $as_echo "not found" >&6; }
8416             as_fn_error $? "User supplied tool LS=$tool_specified does not exist or is not executable" "$LINENO" 5
8417           fi
8418           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8419 $as_echo "$tool_specified" >&6; }
8420         fi
8421       fi
8422     fi
8423 
8424   fi
8425 
8426 
8427 
8428   if test "x$LS" = x; then
8429     as_fn_error $? "Could not find required tool for LS" "$LINENO" 5
8430   fi
8431 
8432 
8433 
8434 
8435 
8436   # Publish this variable in the help.
8437 
8438 
8439   if [ -z "${MKDIR+x}" ]; then
8440     # The variable is not set by user, try to locate tool using the code snippet
8441     for ac_prog in mkdir
8442 do
8443   # Extract the first word of "$ac_prog", so it can be a program name with args.
8444 set dummy $ac_prog; ac_word=$2
8445 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8446 $as_echo_n "checking for $ac_word... " >&6; }
8447 if ${ac_cv_path_MKDIR+:} false; then :
8448   $as_echo_n "(cached) " >&6
8449 else
8450   case $MKDIR in
8451   [\\/]* | ?:[\\/]*)
8452   ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
8453   ;;
8454   *)
8455   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8456 for as_dir in $PATH
8457 do
8458   IFS=$as_save_IFS
8459   test -z "$as_dir" && as_dir=.
8460     for ac_exec_ext in '' $ac_executable_extensions; do
8461   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8462     ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
8463     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8464     break 2
8465   fi
8466 done
8467   done
8468 IFS=$as_save_IFS
8469 
8470   ;;
8471 esac
8472 fi
8473 MKDIR=$ac_cv_path_MKDIR
8474 if test -n "$MKDIR"; then
8475   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
8476 $as_echo "$MKDIR" >&6; }
8477 else
8478   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8479 $as_echo "no" >&6; }
8480 fi
8481 
8482 
8483   test -n "$MKDIR" && break
8484 done
8485 
8486   else
8487     # The variable is set, but is it from the command line or the environment?
8488 
8489     # Try to remove the string !MKDIR! from our list.
8490     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MKDIR!/}
8491     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8492       # If it failed, the variable was not from the command line. Ignore it,
8493       # but warn the user (except for BASH, which is always set by the calling BASH).
8494       if test "xMKDIR" != xBASH; then
8495         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MKDIR from the environment. Use command line variables instead." >&5
8496 $as_echo "$as_me: WARNING: Ignoring value of MKDIR from the environment. Use command line variables instead." >&2;}
8497       fi
8498       # Try to locate tool using the code snippet
8499       for ac_prog in mkdir
8500 do
8501   # Extract the first word of "$ac_prog", so it can be a program name with args.
8502 set dummy $ac_prog; ac_word=$2
8503 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8504 $as_echo_n "checking for $ac_word... " >&6; }
8505 if ${ac_cv_path_MKDIR+:} false; then :
8506   $as_echo_n "(cached) " >&6
8507 else
8508   case $MKDIR in
8509   [\\/]* | ?:[\\/]*)
8510   ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
8511   ;;
8512   *)
8513   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8514 for as_dir in $PATH
8515 do
8516   IFS=$as_save_IFS
8517   test -z "$as_dir" && as_dir=.
8518     for ac_exec_ext in '' $ac_executable_extensions; do
8519   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8520     ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
8521     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8522     break 2
8523   fi
8524 done
8525   done
8526 IFS=$as_save_IFS
8527 
8528   ;;
8529 esac
8530 fi
8531 MKDIR=$ac_cv_path_MKDIR
8532 if test -n "$MKDIR"; then
8533   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
8534 $as_echo "$MKDIR" >&6; }
8535 else
8536   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8537 $as_echo "no" >&6; }
8538 fi
8539 
8540 
8541   test -n "$MKDIR" && break
8542 done
8543 
8544     else
8545       # If it succeeded, then it was overridden by the user. We will use it
8546       # for the tool.
8547 
8548       # First remove it from the list of overridden variables, so we can test
8549       # for unknown variables in the end.
8550       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8551 
8552       # Check if we try to supply an empty value
8553       if test "x$MKDIR" = x; then
8554         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool MKDIR= (no value)" >&5
8555 $as_echo "$as_me: Setting user supplied tool MKDIR= (no value)" >&6;}
8556         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKDIR" >&5
8557 $as_echo_n "checking for MKDIR... " >&6; }
8558         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
8559 $as_echo "disabled" >&6; }
8560       else
8561         # Check if the provided tool contains a complete path.
8562         tool_specified="$MKDIR"
8563         tool_basename="${tool_specified##*/}"
8564         if test "x$tool_basename" = "x$tool_specified"; then
8565           # A command without a complete path is provided, search $PATH.
8566           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MKDIR=$tool_basename" >&5
8567 $as_echo "$as_me: Will search for user supplied tool MKDIR=$tool_basename" >&6;}
8568           # Extract the first word of "$tool_basename", so it can be a program name with args.
8569 set dummy $tool_basename; ac_word=$2
8570 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8571 $as_echo_n "checking for $ac_word... " >&6; }
8572 if ${ac_cv_path_MKDIR+:} false; then :
8573   $as_echo_n "(cached) " >&6
8574 else
8575   case $MKDIR in
8576   [\\/]* | ?:[\\/]*)
8577   ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
8578   ;;
8579   *)
8580   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8581 for as_dir in $PATH
8582 do
8583   IFS=$as_save_IFS
8584   test -z "$as_dir" && as_dir=.
8585     for ac_exec_ext in '' $ac_executable_extensions; do
8586   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8587     ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
8588     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8589     break 2
8590   fi
8591 done
8592   done
8593 IFS=$as_save_IFS
8594 
8595   ;;
8596 esac
8597 fi
8598 MKDIR=$ac_cv_path_MKDIR
8599 if test -n "$MKDIR"; then
8600   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
8601 $as_echo "$MKDIR" >&6; }
8602 else
8603   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8604 $as_echo "no" >&6; }
8605 fi
8606 
8607 
8608           if test "x$MKDIR" = x; then
8609             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8610           fi
8611         else
8612           # Otherwise we believe it is a complete path. Use it as it is.
8613           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MKDIR=$tool_specified" >&5
8614 $as_echo "$as_me: Will use user supplied tool MKDIR=$tool_specified" >&6;}
8615           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKDIR" >&5
8616 $as_echo_n "checking for MKDIR... " >&6; }
8617           if test ! -x "$tool_specified"; then
8618             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8619 $as_echo "not found" >&6; }
8620             as_fn_error $? "User supplied tool MKDIR=$tool_specified does not exist or is not executable" "$LINENO" 5
8621           fi
8622           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8623 $as_echo "$tool_specified" >&6; }
8624         fi
8625       fi
8626     fi
8627 
8628   fi
8629 
8630 
8631 
8632   if test "x$MKDIR" = x; then
8633     as_fn_error $? "Could not find required tool for MKDIR" "$LINENO" 5
8634   fi
8635 
8636 
8637 
8638 
8639 
8640   # Publish this variable in the help.
8641 
8642 
8643   if [ -z "${MKTEMP+x}" ]; then
8644     # The variable is not set by user, try to locate tool using the code snippet
8645     for ac_prog in mktemp
8646 do
8647   # Extract the first word of "$ac_prog", so it can be a program name with args.
8648 set dummy $ac_prog; ac_word=$2
8649 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8650 $as_echo_n "checking for $ac_word... " >&6; }
8651 if ${ac_cv_path_MKTEMP+:} false; then :
8652   $as_echo_n "(cached) " >&6
8653 else
8654   case $MKTEMP in
8655   [\\/]* | ?:[\\/]*)
8656   ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
8657   ;;
8658   *)
8659   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8660 for as_dir in $PATH
8661 do
8662   IFS=$as_save_IFS
8663   test -z "$as_dir" && as_dir=.
8664     for ac_exec_ext in '' $ac_executable_extensions; do
8665   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8666     ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
8667     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8668     break 2
8669   fi
8670 done
8671   done
8672 IFS=$as_save_IFS
8673 
8674   ;;
8675 esac
8676 fi
8677 MKTEMP=$ac_cv_path_MKTEMP
8678 if test -n "$MKTEMP"; then
8679   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
8680 $as_echo "$MKTEMP" >&6; }
8681 else
8682   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8683 $as_echo "no" >&6; }
8684 fi
8685 
8686 
8687   test -n "$MKTEMP" && break
8688 done
8689 
8690   else
8691     # The variable is set, but is it from the command line or the environment?
8692 
8693     # Try to remove the string !MKTEMP! from our list.
8694     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MKTEMP!/}
8695     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8696       # If it failed, the variable was not from the command line. Ignore it,
8697       # but warn the user (except for BASH, which is always set by the calling BASH).
8698       if test "xMKTEMP" != xBASH; then
8699         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MKTEMP from the environment. Use command line variables instead." >&5
8700 $as_echo "$as_me: WARNING: Ignoring value of MKTEMP from the environment. Use command line variables instead." >&2;}
8701       fi
8702       # Try to locate tool using the code snippet
8703       for ac_prog in mktemp
8704 do
8705   # Extract the first word of "$ac_prog", so it can be a program name with args.
8706 set dummy $ac_prog; ac_word=$2
8707 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8708 $as_echo_n "checking for $ac_word... " >&6; }
8709 if ${ac_cv_path_MKTEMP+:} false; then :
8710   $as_echo_n "(cached) " >&6
8711 else
8712   case $MKTEMP in
8713   [\\/]* | ?:[\\/]*)
8714   ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
8715   ;;
8716   *)
8717   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8718 for as_dir in $PATH
8719 do
8720   IFS=$as_save_IFS
8721   test -z "$as_dir" && as_dir=.
8722     for ac_exec_ext in '' $ac_executable_extensions; do
8723   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8724     ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
8725     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8726     break 2
8727   fi
8728 done
8729   done
8730 IFS=$as_save_IFS
8731 
8732   ;;
8733 esac
8734 fi
8735 MKTEMP=$ac_cv_path_MKTEMP
8736 if test -n "$MKTEMP"; then
8737   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
8738 $as_echo "$MKTEMP" >&6; }
8739 else
8740   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8741 $as_echo "no" >&6; }
8742 fi
8743 
8744 
8745   test -n "$MKTEMP" && break
8746 done
8747 
8748     else
8749       # If it succeeded, then it was overridden by the user. We will use it
8750       # for the tool.
8751 
8752       # First remove it from the list of overridden variables, so we can test
8753       # for unknown variables in the end.
8754       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8755 
8756       # Check if we try to supply an empty value
8757       if test "x$MKTEMP" = x; then
8758         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool MKTEMP= (no value)" >&5
8759 $as_echo "$as_me: Setting user supplied tool MKTEMP= (no value)" >&6;}
8760         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKTEMP" >&5
8761 $as_echo_n "checking for MKTEMP... " >&6; }
8762         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
8763 $as_echo "disabled" >&6; }
8764       else
8765         # Check if the provided tool contains a complete path.
8766         tool_specified="$MKTEMP"
8767         tool_basename="${tool_specified##*/}"
8768         if test "x$tool_basename" = "x$tool_specified"; then
8769           # A command without a complete path is provided, search $PATH.
8770           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MKTEMP=$tool_basename" >&5
8771 $as_echo "$as_me: Will search for user supplied tool MKTEMP=$tool_basename" >&6;}
8772           # Extract the first word of "$tool_basename", so it can be a program name with args.
8773 set dummy $tool_basename; ac_word=$2
8774 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8775 $as_echo_n "checking for $ac_word... " >&6; }
8776 if ${ac_cv_path_MKTEMP+:} false; then :
8777   $as_echo_n "(cached) " >&6
8778 else
8779   case $MKTEMP in
8780   [\\/]* | ?:[\\/]*)
8781   ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
8782   ;;
8783   *)
8784   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8785 for as_dir in $PATH
8786 do
8787   IFS=$as_save_IFS
8788   test -z "$as_dir" && as_dir=.
8789     for ac_exec_ext in '' $ac_executable_extensions; do
8790   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8791     ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
8792     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8793     break 2
8794   fi
8795 done
8796   done
8797 IFS=$as_save_IFS
8798 
8799   ;;
8800 esac
8801 fi
8802 MKTEMP=$ac_cv_path_MKTEMP
8803 if test -n "$MKTEMP"; then
8804   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
8805 $as_echo "$MKTEMP" >&6; }
8806 else
8807   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8808 $as_echo "no" >&6; }
8809 fi
8810 
8811 
8812           if test "x$MKTEMP" = x; then
8813             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8814           fi
8815         else
8816           # Otherwise we believe it is a complete path. Use it as it is.
8817           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MKTEMP=$tool_specified" >&5
8818 $as_echo "$as_me: Will use user supplied tool MKTEMP=$tool_specified" >&6;}
8819           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKTEMP" >&5
8820 $as_echo_n "checking for MKTEMP... " >&6; }
8821           if test ! -x "$tool_specified"; then
8822             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8823 $as_echo "not found" >&6; }
8824             as_fn_error $? "User supplied tool MKTEMP=$tool_specified does not exist or is not executable" "$LINENO" 5
8825           fi
8826           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8827 $as_echo "$tool_specified" >&6; }
8828         fi
8829       fi
8830     fi
8831 
8832   fi
8833 
8834 
8835 
8836   if test "x$MKTEMP" = x; then
8837     as_fn_error $? "Could not find required tool for MKTEMP" "$LINENO" 5
8838   fi
8839 
8840 
8841 
8842 
8843 
8844   # Publish this variable in the help.
8845 
8846 
8847   if [ -z "${MV+x}" ]; then
8848     # The variable is not set by user, try to locate tool using the code snippet
8849     for ac_prog in mv
8850 do
8851   # Extract the first word of "$ac_prog", so it can be a program name with args.
8852 set dummy $ac_prog; ac_word=$2
8853 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8854 $as_echo_n "checking for $ac_word... " >&6; }
8855 if ${ac_cv_path_MV+:} false; then :
8856   $as_echo_n "(cached) " >&6
8857 else
8858   case $MV in
8859   [\\/]* | ?:[\\/]*)
8860   ac_cv_path_MV="$MV" # Let the user override the test with a path.
8861   ;;
8862   *)
8863   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8864 for as_dir in $PATH
8865 do
8866   IFS=$as_save_IFS
8867   test -z "$as_dir" && as_dir=.
8868     for ac_exec_ext in '' $ac_executable_extensions; do
8869   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8870     ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
8871     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8872     break 2
8873   fi
8874 done
8875   done
8876 IFS=$as_save_IFS
8877 
8878   ;;
8879 esac
8880 fi
8881 MV=$ac_cv_path_MV
8882 if test -n "$MV"; then
8883   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
8884 $as_echo "$MV" >&6; }
8885 else
8886   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8887 $as_echo "no" >&6; }
8888 fi
8889 
8890 
8891   test -n "$MV" && break
8892 done
8893 
8894   else
8895     # The variable is set, but is it from the command line or the environment?
8896 
8897     # Try to remove the string !MV! from our list.
8898     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MV!/}
8899     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8900       # If it failed, the variable was not from the command line. Ignore it,
8901       # but warn the user (except for BASH, which is always set by the calling BASH).
8902       if test "xMV" != xBASH; then
8903         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MV from the environment. Use command line variables instead." >&5
8904 $as_echo "$as_me: WARNING: Ignoring value of MV from the environment. Use command line variables instead." >&2;}
8905       fi
8906       # Try to locate tool using the code snippet
8907       for ac_prog in mv
8908 do
8909   # Extract the first word of "$ac_prog", so it can be a program name with args.
8910 set dummy $ac_prog; ac_word=$2
8911 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8912 $as_echo_n "checking for $ac_word... " >&6; }
8913 if ${ac_cv_path_MV+:} false; then :
8914   $as_echo_n "(cached) " >&6
8915 else
8916   case $MV in
8917   [\\/]* | ?:[\\/]*)
8918   ac_cv_path_MV="$MV" # Let the user override the test with a path.
8919   ;;
8920   *)
8921   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8922 for as_dir in $PATH
8923 do
8924   IFS=$as_save_IFS
8925   test -z "$as_dir" && as_dir=.
8926     for ac_exec_ext in '' $ac_executable_extensions; do
8927   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8928     ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
8929     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8930     break 2
8931   fi
8932 done
8933   done
8934 IFS=$as_save_IFS
8935 
8936   ;;
8937 esac
8938 fi
8939 MV=$ac_cv_path_MV
8940 if test -n "$MV"; then
8941   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
8942 $as_echo "$MV" >&6; }
8943 else
8944   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8945 $as_echo "no" >&6; }
8946 fi
8947 
8948 
8949   test -n "$MV" && break
8950 done
8951 
8952     else
8953       # If it succeeded, then it was overridden by the user. We will use it
8954       # for the tool.
8955 
8956       # First remove it from the list of overridden variables, so we can test
8957       # for unknown variables in the end.
8958       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8959 
8960       # Check if we try to supply an empty value
8961       if test "x$MV" = x; then
8962         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool MV= (no value)" >&5
8963 $as_echo "$as_me: Setting user supplied tool MV= (no value)" >&6;}
8964         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MV" >&5
8965 $as_echo_n "checking for MV... " >&6; }
8966         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
8967 $as_echo "disabled" >&6; }
8968       else
8969         # Check if the provided tool contains a complete path.
8970         tool_specified="$MV"
8971         tool_basename="${tool_specified##*/}"
8972         if test "x$tool_basename" = "x$tool_specified"; then
8973           # A command without a complete path is provided, search $PATH.
8974           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MV=$tool_basename" >&5
8975 $as_echo "$as_me: Will search for user supplied tool MV=$tool_basename" >&6;}
8976           # Extract the first word of "$tool_basename", so it can be a program name with args.
8977 set dummy $tool_basename; ac_word=$2
8978 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8979 $as_echo_n "checking for $ac_word... " >&6; }
8980 if ${ac_cv_path_MV+:} false; then :
8981   $as_echo_n "(cached) " >&6
8982 else
8983   case $MV in
8984   [\\/]* | ?:[\\/]*)
8985   ac_cv_path_MV="$MV" # Let the user override the test with a path.
8986   ;;
8987   *)
8988   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8989 for as_dir in $PATH
8990 do
8991   IFS=$as_save_IFS
8992   test -z "$as_dir" && as_dir=.
8993     for ac_exec_ext in '' $ac_executable_extensions; do
8994   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8995     ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
8996     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8997     break 2
8998   fi
8999 done
9000   done
9001 IFS=$as_save_IFS
9002 
9003   ;;
9004 esac
9005 fi
9006 MV=$ac_cv_path_MV
9007 if test -n "$MV"; then
9008   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
9009 $as_echo "$MV" >&6; }
9010 else
9011   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9012 $as_echo "no" >&6; }
9013 fi
9014 
9015 
9016           if test "x$MV" = x; then
9017             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9018           fi
9019         else
9020           # Otherwise we believe it is a complete path. Use it as it is.
9021           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MV=$tool_specified" >&5
9022 $as_echo "$as_me: Will use user supplied tool MV=$tool_specified" >&6;}
9023           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MV" >&5
9024 $as_echo_n "checking for MV... " >&6; }
9025           if test ! -x "$tool_specified"; then
9026             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9027 $as_echo "not found" >&6; }
9028             as_fn_error $? "User supplied tool MV=$tool_specified does not exist or is not executable" "$LINENO" 5
9029           fi
9030           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9031 $as_echo "$tool_specified" >&6; }
9032         fi
9033       fi
9034     fi
9035 
9036   fi
9037 
9038 
9039 
9040   if test "x$MV" = x; then
9041     as_fn_error $? "Could not find required tool for MV" "$LINENO" 5
9042   fi
9043 
9044 
9045 
9046 
9047 
9048   # Publish this variable in the help.
9049 
9050 
9051   if [ -z "${NAWK+x}" ]; then
9052     # The variable is not set by user, try to locate tool using the code snippet
9053     for ac_prog in nawk gawk awk
9054 do
9055   # Extract the first word of "$ac_prog", so it can be a program name with args.
9056 set dummy $ac_prog; ac_word=$2
9057 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9058 $as_echo_n "checking for $ac_word... " >&6; }
9059 if ${ac_cv_path_NAWK+:} false; then :
9060   $as_echo_n "(cached) " >&6
9061 else
9062   case $NAWK in
9063   [\\/]* | ?:[\\/]*)
9064   ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
9065   ;;
9066   *)
9067   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9068 for as_dir in $PATH
9069 do
9070   IFS=$as_save_IFS
9071   test -z "$as_dir" && as_dir=.
9072     for ac_exec_ext in '' $ac_executable_extensions; do
9073   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9074     ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
9075     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9076     break 2
9077   fi
9078 done
9079   done
9080 IFS=$as_save_IFS
9081 
9082   ;;
9083 esac
9084 fi
9085 NAWK=$ac_cv_path_NAWK
9086 if test -n "$NAWK"; then
9087   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
9088 $as_echo "$NAWK" >&6; }
9089 else
9090   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9091 $as_echo "no" >&6; }
9092 fi
9093 
9094 
9095   test -n "$NAWK" && break
9096 done
9097 
9098   else
9099     # The variable is set, but is it from the command line or the environment?
9100 
9101     # Try to remove the string !NAWK! from our list.
9102     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!NAWK!/}
9103     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9104       # If it failed, the variable was not from the command line. Ignore it,
9105       # but warn the user (except for BASH, which is always set by the calling BASH).
9106       if test "xNAWK" != xBASH; then
9107         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of NAWK from the environment. Use command line variables instead." >&5
9108 $as_echo "$as_me: WARNING: Ignoring value of NAWK from the environment. Use command line variables instead." >&2;}
9109       fi
9110       # Try to locate tool using the code snippet
9111       for ac_prog in nawk gawk awk
9112 do
9113   # Extract the first word of "$ac_prog", so it can be a program name with args.
9114 set dummy $ac_prog; ac_word=$2
9115 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9116 $as_echo_n "checking for $ac_word... " >&6; }
9117 if ${ac_cv_path_NAWK+:} false; then :
9118   $as_echo_n "(cached) " >&6
9119 else
9120   case $NAWK in
9121   [\\/]* | ?:[\\/]*)
9122   ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
9123   ;;
9124   *)
9125   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9126 for as_dir in $PATH
9127 do
9128   IFS=$as_save_IFS
9129   test -z "$as_dir" && as_dir=.
9130     for ac_exec_ext in '' $ac_executable_extensions; do
9131   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9132     ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
9133     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9134     break 2
9135   fi
9136 done
9137   done
9138 IFS=$as_save_IFS
9139 
9140   ;;
9141 esac
9142 fi
9143 NAWK=$ac_cv_path_NAWK
9144 if test -n "$NAWK"; then
9145   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
9146 $as_echo "$NAWK" >&6; }
9147 else
9148   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9149 $as_echo "no" >&6; }
9150 fi
9151 
9152 
9153   test -n "$NAWK" && break
9154 done
9155 
9156     else
9157       # If it succeeded, then it was overridden by the user. We will use it
9158       # for the tool.
9159 
9160       # First remove it from the list of overridden variables, so we can test
9161       # for unknown variables in the end.
9162       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9163 
9164       # Check if we try to supply an empty value
9165       if test "x$NAWK" = x; then
9166         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool NAWK= (no value)" >&5
9167 $as_echo "$as_me: Setting user supplied tool NAWK= (no value)" >&6;}
9168         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NAWK" >&5
9169 $as_echo_n "checking for NAWK... " >&6; }
9170         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
9171 $as_echo "disabled" >&6; }
9172       else
9173         # Check if the provided tool contains a complete path.
9174         tool_specified="$NAWK"
9175         tool_basename="${tool_specified##*/}"
9176         if test "x$tool_basename" = "x$tool_specified"; then
9177           # A command without a complete path is provided, search $PATH.
9178           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool NAWK=$tool_basename" >&5
9179 $as_echo "$as_me: Will search for user supplied tool NAWK=$tool_basename" >&6;}
9180           # Extract the first word of "$tool_basename", so it can be a program name with args.
9181 set dummy $tool_basename; ac_word=$2
9182 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9183 $as_echo_n "checking for $ac_word... " >&6; }
9184 if ${ac_cv_path_NAWK+:} false; then :
9185   $as_echo_n "(cached) " >&6
9186 else
9187   case $NAWK in
9188   [\\/]* | ?:[\\/]*)
9189   ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
9190   ;;
9191   *)
9192   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9193 for as_dir in $PATH
9194 do
9195   IFS=$as_save_IFS
9196   test -z "$as_dir" && as_dir=.
9197     for ac_exec_ext in '' $ac_executable_extensions; do
9198   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9199     ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
9200     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9201     break 2
9202   fi
9203 done
9204   done
9205 IFS=$as_save_IFS
9206 
9207   ;;
9208 esac
9209 fi
9210 NAWK=$ac_cv_path_NAWK
9211 if test -n "$NAWK"; then
9212   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
9213 $as_echo "$NAWK" >&6; }
9214 else
9215   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9216 $as_echo "no" >&6; }
9217 fi
9218 
9219 
9220           if test "x$NAWK" = x; then
9221             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9222           fi
9223         else
9224           # Otherwise we believe it is a complete path. Use it as it is.
9225           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool NAWK=$tool_specified" >&5
9226 $as_echo "$as_me: Will use user supplied tool NAWK=$tool_specified" >&6;}
9227           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NAWK" >&5
9228 $as_echo_n "checking for NAWK... " >&6; }
9229           if test ! -x "$tool_specified"; then
9230             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9231 $as_echo "not found" >&6; }
9232             as_fn_error $? "User supplied tool NAWK=$tool_specified does not exist or is not executable" "$LINENO" 5
9233           fi
9234           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9235 $as_echo "$tool_specified" >&6; }
9236         fi
9237       fi
9238     fi
9239 
9240   fi
9241 
9242 
9243 
9244   if test "x$NAWK" = x; then
9245     as_fn_error $? "Could not find required tool for NAWK" "$LINENO" 5
9246   fi
9247 
9248 
9249 
9250 
9251 
9252   # Publish this variable in the help.
9253 
9254 
9255   if [ -z "${PRINTF+x}" ]; then
9256     # The variable is not set by user, try to locate tool using the code snippet
9257     for ac_prog in printf
9258 do
9259   # Extract the first word of "$ac_prog", so it can be a program name with args.
9260 set dummy $ac_prog; ac_word=$2
9261 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9262 $as_echo_n "checking for $ac_word... " >&6; }
9263 if ${ac_cv_path_PRINTF+:} false; then :
9264   $as_echo_n "(cached) " >&6
9265 else
9266   case $PRINTF in
9267   [\\/]* | ?:[\\/]*)
9268   ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
9269   ;;
9270   *)
9271   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9272 for as_dir in $PATH
9273 do
9274   IFS=$as_save_IFS
9275   test -z "$as_dir" && as_dir=.
9276     for ac_exec_ext in '' $ac_executable_extensions; do
9277   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9278     ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
9279     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9280     break 2
9281   fi
9282 done
9283   done
9284 IFS=$as_save_IFS
9285 
9286   ;;
9287 esac
9288 fi
9289 PRINTF=$ac_cv_path_PRINTF
9290 if test -n "$PRINTF"; then
9291   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
9292 $as_echo "$PRINTF" >&6; }
9293 else
9294   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9295 $as_echo "no" >&6; }
9296 fi
9297 
9298 
9299   test -n "$PRINTF" && break
9300 done
9301 
9302   else
9303     # The variable is set, but is it from the command line or the environment?
9304 
9305     # Try to remove the string !PRINTF! from our list.
9306     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!PRINTF!/}
9307     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9308       # If it failed, the variable was not from the command line. Ignore it,
9309       # but warn the user (except for BASH, which is always set by the calling BASH).
9310       if test "xPRINTF" != xBASH; then
9311         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of PRINTF from the environment. Use command line variables instead." >&5
9312 $as_echo "$as_me: WARNING: Ignoring value of PRINTF from the environment. Use command line variables instead." >&2;}
9313       fi
9314       # Try to locate tool using the code snippet
9315       for ac_prog in printf
9316 do
9317   # Extract the first word of "$ac_prog", so it can be a program name with args.
9318 set dummy $ac_prog; ac_word=$2
9319 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9320 $as_echo_n "checking for $ac_word... " >&6; }
9321 if ${ac_cv_path_PRINTF+:} false; then :
9322   $as_echo_n "(cached) " >&6
9323 else
9324   case $PRINTF in
9325   [\\/]* | ?:[\\/]*)
9326   ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
9327   ;;
9328   *)
9329   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9330 for as_dir in $PATH
9331 do
9332   IFS=$as_save_IFS
9333   test -z "$as_dir" && as_dir=.
9334     for ac_exec_ext in '' $ac_executable_extensions; do
9335   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9336     ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
9337     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9338     break 2
9339   fi
9340 done
9341   done
9342 IFS=$as_save_IFS
9343 
9344   ;;
9345 esac
9346 fi
9347 PRINTF=$ac_cv_path_PRINTF
9348 if test -n "$PRINTF"; then
9349   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
9350 $as_echo "$PRINTF" >&6; }
9351 else
9352   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9353 $as_echo "no" >&6; }
9354 fi
9355 
9356 
9357   test -n "$PRINTF" && break
9358 done
9359 
9360     else
9361       # If it succeeded, then it was overridden by the user. We will use it
9362       # for the tool.
9363 
9364       # First remove it from the list of overridden variables, so we can test
9365       # for unknown variables in the end.
9366       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9367 
9368       # Check if we try to supply an empty value
9369       if test "x$PRINTF" = x; then
9370         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool PRINTF= (no value)" >&5
9371 $as_echo "$as_me: Setting user supplied tool PRINTF= (no value)" >&6;}
9372         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PRINTF" >&5
9373 $as_echo_n "checking for PRINTF... " >&6; }
9374         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
9375 $as_echo "disabled" >&6; }
9376       else
9377         # Check if the provided tool contains a complete path.
9378         tool_specified="$PRINTF"
9379         tool_basename="${tool_specified##*/}"
9380         if test "x$tool_basename" = "x$tool_specified"; then
9381           # A command without a complete path is provided, search $PATH.
9382           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool PRINTF=$tool_basename" >&5
9383 $as_echo "$as_me: Will search for user supplied tool PRINTF=$tool_basename" >&6;}
9384           # Extract the first word of "$tool_basename", so it can be a program name with args.
9385 set dummy $tool_basename; ac_word=$2
9386 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9387 $as_echo_n "checking for $ac_word... " >&6; }
9388 if ${ac_cv_path_PRINTF+:} false; then :
9389   $as_echo_n "(cached) " >&6
9390 else
9391   case $PRINTF in
9392   [\\/]* | ?:[\\/]*)
9393   ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
9394   ;;
9395   *)
9396   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9397 for as_dir in $PATH
9398 do
9399   IFS=$as_save_IFS
9400   test -z "$as_dir" && as_dir=.
9401     for ac_exec_ext in '' $ac_executable_extensions; do
9402   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9403     ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
9404     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9405     break 2
9406   fi
9407 done
9408   done
9409 IFS=$as_save_IFS
9410 
9411   ;;
9412 esac
9413 fi
9414 PRINTF=$ac_cv_path_PRINTF
9415 if test -n "$PRINTF"; then
9416   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
9417 $as_echo "$PRINTF" >&6; }
9418 else
9419   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9420 $as_echo "no" >&6; }
9421 fi
9422 
9423 
9424           if test "x$PRINTF" = x; then
9425             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9426           fi
9427         else
9428           # Otherwise we believe it is a complete path. Use it as it is.
9429           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool PRINTF=$tool_specified" >&5
9430 $as_echo "$as_me: Will use user supplied tool PRINTF=$tool_specified" >&6;}
9431           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PRINTF" >&5
9432 $as_echo_n "checking for PRINTF... " >&6; }
9433           if test ! -x "$tool_specified"; then
9434             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9435 $as_echo "not found" >&6; }
9436             as_fn_error $? "User supplied tool PRINTF=$tool_specified does not exist or is not executable" "$LINENO" 5
9437           fi
9438           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9439 $as_echo "$tool_specified" >&6; }
9440         fi
9441       fi
9442     fi
9443 
9444   fi
9445 
9446 
9447 
9448   if test "x$PRINTF" = x; then
9449     as_fn_error $? "Could not find required tool for PRINTF" "$LINENO" 5
9450   fi
9451 
9452 
9453 
9454 
9455 
9456   # Publish this variable in the help.
9457 
9458 
9459   if [ -z "${RM+x}" ]; then
9460     # The variable is not set by user, try to locate tool using the code snippet
9461     for ac_prog in rm
9462 do
9463   # Extract the first word of "$ac_prog", so it can be a program name with args.
9464 set dummy $ac_prog; ac_word=$2
9465 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9466 $as_echo_n "checking for $ac_word... " >&6; }
9467 if ${ac_cv_path_RM+:} false; then :
9468   $as_echo_n "(cached) " >&6
9469 else
9470   case $RM in
9471   [\\/]* | ?:[\\/]*)
9472   ac_cv_path_RM="$RM" # Let the user override the test with a path.
9473   ;;
9474   *)
9475   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9476 for as_dir in $PATH
9477 do
9478   IFS=$as_save_IFS
9479   test -z "$as_dir" && as_dir=.
9480     for ac_exec_ext in '' $ac_executable_extensions; do
9481   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9482     ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
9483     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9484     break 2
9485   fi
9486 done
9487   done
9488 IFS=$as_save_IFS
9489 
9490   ;;
9491 esac
9492 fi
9493 RM=$ac_cv_path_RM
9494 if test -n "$RM"; then
9495   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
9496 $as_echo "$RM" >&6; }
9497 else
9498   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9499 $as_echo "no" >&6; }
9500 fi
9501 
9502 
9503   test -n "$RM" && break
9504 done
9505 
9506   else
9507     # The variable is set, but is it from the command line or the environment?
9508 
9509     # Try to remove the string !RM! from our list.
9510     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!RM!/}
9511     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9512       # If it failed, the variable was not from the command line. Ignore it,
9513       # but warn the user (except for BASH, which is always set by the calling BASH).
9514       if test "xRM" != xBASH; then
9515         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of RM from the environment. Use command line variables instead." >&5
9516 $as_echo "$as_me: WARNING: Ignoring value of RM from the environment. Use command line variables instead." >&2;}
9517       fi
9518       # Try to locate tool using the code snippet
9519       for ac_prog in rm
9520 do
9521   # Extract the first word of "$ac_prog", so it can be a program name with args.
9522 set dummy $ac_prog; ac_word=$2
9523 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9524 $as_echo_n "checking for $ac_word... " >&6; }
9525 if ${ac_cv_path_RM+:} false; then :
9526   $as_echo_n "(cached) " >&6
9527 else
9528   case $RM in
9529   [\\/]* | ?:[\\/]*)
9530   ac_cv_path_RM="$RM" # Let the user override the test with a path.
9531   ;;
9532   *)
9533   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9534 for as_dir in $PATH
9535 do
9536   IFS=$as_save_IFS
9537   test -z "$as_dir" && as_dir=.
9538     for ac_exec_ext in '' $ac_executable_extensions; do
9539   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9540     ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
9541     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9542     break 2
9543   fi
9544 done
9545   done
9546 IFS=$as_save_IFS
9547 
9548   ;;
9549 esac
9550 fi
9551 RM=$ac_cv_path_RM
9552 if test -n "$RM"; then
9553   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
9554 $as_echo "$RM" >&6; }
9555 else
9556   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9557 $as_echo "no" >&6; }
9558 fi
9559 
9560 
9561   test -n "$RM" && break
9562 done
9563 
9564     else
9565       # If it succeeded, then it was overridden by the user. We will use it
9566       # for the tool.
9567 
9568       # First remove it from the list of overridden variables, so we can test
9569       # for unknown variables in the end.
9570       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9571 
9572       # Check if we try to supply an empty value
9573       if test "x$RM" = x; then
9574         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool RM= (no value)" >&5
9575 $as_echo "$as_me: Setting user supplied tool RM= (no value)" >&6;}
9576         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for RM" >&5
9577 $as_echo_n "checking for RM... " >&6; }
9578         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
9579 $as_echo "disabled" >&6; }
9580       else
9581         # Check if the provided tool contains a complete path.
9582         tool_specified="$RM"
9583         tool_basename="${tool_specified##*/}"
9584         if test "x$tool_basename" = "x$tool_specified"; then
9585           # A command without a complete path is provided, search $PATH.
9586           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool RM=$tool_basename" >&5
9587 $as_echo "$as_me: Will search for user supplied tool RM=$tool_basename" >&6;}
9588           # Extract the first word of "$tool_basename", so it can be a program name with args.
9589 set dummy $tool_basename; ac_word=$2
9590 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9591 $as_echo_n "checking for $ac_word... " >&6; }
9592 if ${ac_cv_path_RM+:} false; then :
9593   $as_echo_n "(cached) " >&6
9594 else
9595   case $RM in
9596   [\\/]* | ?:[\\/]*)
9597   ac_cv_path_RM="$RM" # Let the user override the test with a path.
9598   ;;
9599   *)
9600   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9601 for as_dir in $PATH
9602 do
9603   IFS=$as_save_IFS
9604   test -z "$as_dir" && as_dir=.
9605     for ac_exec_ext in '' $ac_executable_extensions; do
9606   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9607     ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
9608     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9609     break 2
9610   fi
9611 done
9612   done
9613 IFS=$as_save_IFS
9614 
9615   ;;
9616 esac
9617 fi
9618 RM=$ac_cv_path_RM
9619 if test -n "$RM"; then
9620   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
9621 $as_echo "$RM" >&6; }
9622 else
9623   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9624 $as_echo "no" >&6; }
9625 fi
9626 
9627 
9628           if test "x$RM" = x; then
9629             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9630           fi
9631         else
9632           # Otherwise we believe it is a complete path. Use it as it is.
9633           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool RM=$tool_specified" >&5
9634 $as_echo "$as_me: Will use user supplied tool RM=$tool_specified" >&6;}
9635           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for RM" >&5
9636 $as_echo_n "checking for RM... " >&6; }
9637           if test ! -x "$tool_specified"; then
9638             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9639 $as_echo "not found" >&6; }
9640             as_fn_error $? "User supplied tool RM=$tool_specified does not exist or is not executable" "$LINENO" 5
9641           fi
9642           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9643 $as_echo "$tool_specified" >&6; }
9644         fi
9645       fi
9646     fi
9647 
9648   fi
9649 
9650 
9651 
9652   if test "x$RM" = x; then
9653     as_fn_error $? "Could not find required tool for RM" "$LINENO" 5
9654   fi
9655 
9656 
9657 
9658 
9659 
9660   # Publish this variable in the help.
9661 
9662 
9663   if [ -z "${RMDIR+x}" ]; then
9664     # The variable is not set by user, try to locate tool using the code snippet
9665     for ac_prog in rmdir
9666 do
9667   # Extract the first word of "$ac_prog", so it can be a program name with args.
9668 set dummy $ac_prog; ac_word=$2
9669 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9670 $as_echo_n "checking for $ac_word... " >&6; }
9671 if ${ac_cv_path_RMDIR+:} false; then :
9672   $as_echo_n "(cached) " >&6
9673 else
9674   case $RMDIR in
9675   [\\/]* | ?:[\\/]*)
9676   ac_cv_path_RMDIR="$RMDIR" # Let the user override the test with a path.
9677   ;;
9678   *)
9679   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9680 for as_dir in $PATH
9681 do
9682   IFS=$as_save_IFS
9683   test -z "$as_dir" && as_dir=.
9684     for ac_exec_ext in '' $ac_executable_extensions; do
9685   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9686     ac_cv_path_RMDIR="$as_dir/$ac_word$ac_exec_ext"
9687     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9688     break 2
9689   fi
9690 done
9691   done
9692 IFS=$as_save_IFS
9693 
9694   ;;
9695 esac
9696 fi
9697 RMDIR=$ac_cv_path_RMDIR
9698 if test -n "$RMDIR"; then
9699   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RMDIR" >&5
9700 $as_echo "$RMDIR" >&6; }
9701 else
9702   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9703 $as_echo "no" >&6; }
9704 fi
9705 
9706 
9707   test -n "$RMDIR" && break
9708 done
9709 
9710   else
9711     # The variable is set, but is it from the command line or the environment?
9712 
9713     # Try to remove the string !RMDIR! from our list.
9714     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!RMDIR!/}
9715     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9716       # If it failed, the variable was not from the command line. Ignore it,
9717       # but warn the user (except for BASH, which is always set by the calling BASH).
9718       if test "xRMDIR" != xBASH; then
9719         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of RMDIR from the environment. Use command line variables instead." >&5
9720 $as_echo "$as_me: WARNING: Ignoring value of RMDIR from the environment. Use command line variables instead." >&2;}
9721       fi
9722       # Try to locate tool using the code snippet
9723       for ac_prog in rmdir
9724 do
9725   # Extract the first word of "$ac_prog", so it can be a program name with args.
9726 set dummy $ac_prog; ac_word=$2
9727 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9728 $as_echo_n "checking for $ac_word... " >&6; }
9729 if ${ac_cv_path_RMDIR+:} false; then :
9730   $as_echo_n "(cached) " >&6
9731 else
9732   case $RMDIR in
9733   [\\/]* | ?:[\\/]*)
9734   ac_cv_path_RMDIR="$RMDIR" # Let the user override the test with a path.
9735   ;;
9736   *)
9737   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9738 for as_dir in $PATH
9739 do
9740   IFS=$as_save_IFS
9741   test -z "$as_dir" && as_dir=.
9742     for ac_exec_ext in '' $ac_executable_extensions; do
9743   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9744     ac_cv_path_RMDIR="$as_dir/$ac_word$ac_exec_ext"
9745     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9746     break 2
9747   fi
9748 done
9749   done
9750 IFS=$as_save_IFS
9751 
9752   ;;
9753 esac
9754 fi
9755 RMDIR=$ac_cv_path_RMDIR
9756 if test -n "$RMDIR"; then
9757   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RMDIR" >&5
9758 $as_echo "$RMDIR" >&6; }
9759 else
9760   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9761 $as_echo "no" >&6; }
9762 fi
9763 
9764 
9765   test -n "$RMDIR" && break
9766 done
9767 
9768     else
9769       # If it succeeded, then it was overridden by the user. We will use it
9770       # for the tool.
9771 
9772       # First remove it from the list of overridden variables, so we can test
9773       # for unknown variables in the end.
9774       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9775 
9776       # Check if we try to supply an empty value
9777       if test "x$RMDIR" = x; then
9778         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool RMDIR= (no value)" >&5
9779 $as_echo "$as_me: Setting user supplied tool RMDIR= (no value)" >&6;}
9780         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for RMDIR" >&5
9781 $as_echo_n "checking for RMDIR... " >&6; }
9782         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
9783 $as_echo "disabled" >&6; }
9784       else
9785         # Check if the provided tool contains a complete path.
9786         tool_specified="$RMDIR"
9787         tool_basename="${tool_specified##*/}"
9788         if test "x$tool_basename" = "x$tool_specified"; then
9789           # A command without a complete path is provided, search $PATH.
9790           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool RMDIR=$tool_basename" >&5
9791 $as_echo "$as_me: Will search for user supplied tool RMDIR=$tool_basename" >&6;}
9792           # Extract the first word of "$tool_basename", so it can be a program name with args.
9793 set dummy $tool_basename; ac_word=$2
9794 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9795 $as_echo_n "checking for $ac_word... " >&6; }
9796 if ${ac_cv_path_RMDIR+:} false; then :
9797   $as_echo_n "(cached) " >&6
9798 else
9799   case $RMDIR in
9800   [\\/]* | ?:[\\/]*)
9801   ac_cv_path_RMDIR="$RMDIR" # Let the user override the test with a path.
9802   ;;
9803   *)
9804   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9805 for as_dir in $PATH
9806 do
9807   IFS=$as_save_IFS
9808   test -z "$as_dir" && as_dir=.
9809     for ac_exec_ext in '' $ac_executable_extensions; do
9810   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9811     ac_cv_path_RMDIR="$as_dir/$ac_word$ac_exec_ext"
9812     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9813     break 2
9814   fi
9815 done
9816   done
9817 IFS=$as_save_IFS
9818 
9819   ;;
9820 esac
9821 fi
9822 RMDIR=$ac_cv_path_RMDIR
9823 if test -n "$RMDIR"; then
9824   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RMDIR" >&5
9825 $as_echo "$RMDIR" >&6; }
9826 else
9827   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9828 $as_echo "no" >&6; }
9829 fi
9830 
9831 
9832           if test "x$RMDIR" = x; then
9833             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9834           fi
9835         else
9836           # Otherwise we believe it is a complete path. Use it as it is.
9837           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool RMDIR=$tool_specified" >&5
9838 $as_echo "$as_me: Will use user supplied tool RMDIR=$tool_specified" >&6;}
9839           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for RMDIR" >&5
9840 $as_echo_n "checking for RMDIR... " >&6; }
9841           if test ! -x "$tool_specified"; then
9842             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9843 $as_echo "not found" >&6; }
9844             as_fn_error $? "User supplied tool RMDIR=$tool_specified does not exist or is not executable" "$LINENO" 5
9845           fi
9846           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9847 $as_echo "$tool_specified" >&6; }
9848         fi
9849       fi
9850     fi
9851 
9852   fi
9853 
9854 
9855 
9856   if test "x$RMDIR" = x; then
9857     as_fn_error $? "Could not find required tool for RMDIR" "$LINENO" 5
9858   fi
9859 
9860 
9861 
9862 
9863 
9864   # Publish this variable in the help.
9865 
9866 
9867   if [ -z "${SH+x}" ]; then
9868     # The variable is not set by user, try to locate tool using the code snippet
9869     for ac_prog in sh
9870 do
9871   # Extract the first word of "$ac_prog", so it can be a program name with args.
9872 set dummy $ac_prog; ac_word=$2
9873 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9874 $as_echo_n "checking for $ac_word... " >&6; }
9875 if ${ac_cv_path_SH+:} false; then :
9876   $as_echo_n "(cached) " >&6
9877 else
9878   case $SH in
9879   [\\/]* | ?:[\\/]*)
9880   ac_cv_path_SH="$SH" # Let the user override the test with a path.
9881   ;;
9882   *)
9883   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9884 for as_dir in $PATH
9885 do
9886   IFS=$as_save_IFS
9887   test -z "$as_dir" && as_dir=.
9888     for ac_exec_ext in '' $ac_executable_extensions; do
9889   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9890     ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
9891     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9892     break 2
9893   fi
9894 done
9895   done
9896 IFS=$as_save_IFS
9897 
9898   ;;
9899 esac
9900 fi
9901 SH=$ac_cv_path_SH
9902 if test -n "$SH"; then
9903   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
9904 $as_echo "$SH" >&6; }
9905 else
9906   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9907 $as_echo "no" >&6; }
9908 fi
9909 
9910 
9911   test -n "$SH" && break
9912 done
9913 
9914   else
9915     # The variable is set, but is it from the command line or the environment?
9916 
9917     # Try to remove the string !SH! from our list.
9918     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SH!/}
9919     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9920       # If it failed, the variable was not from the command line. Ignore it,
9921       # but warn the user (except for BASH, which is always set by the calling BASH).
9922       if test "xSH" != xBASH; then
9923         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SH from the environment. Use command line variables instead." >&5
9924 $as_echo "$as_me: WARNING: Ignoring value of SH from the environment. Use command line variables instead." >&2;}
9925       fi
9926       # Try to locate tool using the code snippet
9927       for ac_prog in sh
9928 do
9929   # Extract the first word of "$ac_prog", so it can be a program name with args.
9930 set dummy $ac_prog; ac_word=$2
9931 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9932 $as_echo_n "checking for $ac_word... " >&6; }
9933 if ${ac_cv_path_SH+:} false; then :
9934   $as_echo_n "(cached) " >&6
9935 else
9936   case $SH in
9937   [\\/]* | ?:[\\/]*)
9938   ac_cv_path_SH="$SH" # Let the user override the test with a path.
9939   ;;
9940   *)
9941   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9942 for as_dir in $PATH
9943 do
9944   IFS=$as_save_IFS
9945   test -z "$as_dir" && as_dir=.
9946     for ac_exec_ext in '' $ac_executable_extensions; do
9947   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9948     ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
9949     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9950     break 2
9951   fi
9952 done
9953   done
9954 IFS=$as_save_IFS
9955 
9956   ;;
9957 esac
9958 fi
9959 SH=$ac_cv_path_SH
9960 if test -n "$SH"; then
9961   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
9962 $as_echo "$SH" >&6; }
9963 else
9964   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9965 $as_echo "no" >&6; }
9966 fi
9967 
9968 
9969   test -n "$SH" && break
9970 done
9971 
9972     else
9973       # If it succeeded, then it was overridden by the user. We will use it
9974       # for the tool.
9975 
9976       # First remove it from the list of overridden variables, so we can test
9977       # for unknown variables in the end.
9978       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9979 
9980       # Check if we try to supply an empty value
9981       if test "x$SH" = x; then
9982         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool SH= (no value)" >&5
9983 $as_echo "$as_me: Setting user supplied tool SH= (no value)" >&6;}
9984         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SH" >&5
9985 $as_echo_n "checking for SH... " >&6; }
9986         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
9987 $as_echo "disabled" >&6; }
9988       else
9989         # Check if the provided tool contains a complete path.
9990         tool_specified="$SH"
9991         tool_basename="${tool_specified##*/}"
9992         if test "x$tool_basename" = "x$tool_specified"; then
9993           # A command without a complete path is provided, search $PATH.
9994           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SH=$tool_basename" >&5
9995 $as_echo "$as_me: Will search for user supplied tool SH=$tool_basename" >&6;}
9996           # Extract the first word of "$tool_basename", so it can be a program name with args.
9997 set dummy $tool_basename; ac_word=$2
9998 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9999 $as_echo_n "checking for $ac_word... " >&6; }
10000 if ${ac_cv_path_SH+:} false; then :
10001   $as_echo_n "(cached) " >&6
10002 else
10003   case $SH in
10004   [\\/]* | ?:[\\/]*)
10005   ac_cv_path_SH="$SH" # Let the user override the test with a path.
10006   ;;
10007   *)
10008   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10009 for as_dir in $PATH
10010 do
10011   IFS=$as_save_IFS
10012   test -z "$as_dir" && as_dir=.
10013     for ac_exec_ext in '' $ac_executable_extensions; do
10014   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10015     ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
10016     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10017     break 2
10018   fi
10019 done
10020   done
10021 IFS=$as_save_IFS
10022 
10023   ;;
10024 esac
10025 fi
10026 SH=$ac_cv_path_SH
10027 if test -n "$SH"; then
10028   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
10029 $as_echo "$SH" >&6; }
10030 else
10031   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10032 $as_echo "no" >&6; }
10033 fi
10034 
10035 
10036           if test "x$SH" = x; then
10037             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10038           fi
10039         else
10040           # Otherwise we believe it is a complete path. Use it as it is.
10041           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SH=$tool_specified" >&5
10042 $as_echo "$as_me: Will use user supplied tool SH=$tool_specified" >&6;}
10043           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SH" >&5
10044 $as_echo_n "checking for SH... " >&6; }
10045           if test ! -x "$tool_specified"; then
10046             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10047 $as_echo "not found" >&6; }
10048             as_fn_error $? "User supplied tool SH=$tool_specified does not exist or is not executable" "$LINENO" 5
10049           fi
10050           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10051 $as_echo "$tool_specified" >&6; }
10052         fi
10053       fi
10054     fi
10055 
10056   fi
10057 
10058 
10059 
10060   if test "x$SH" = x; then
10061     as_fn_error $? "Could not find required tool for SH" "$LINENO" 5
10062   fi
10063 
10064 
10065 
10066 
10067 
10068   # Publish this variable in the help.
10069 
10070 
10071   if [ -z "${SORT+x}" ]; then
10072     # The variable is not set by user, try to locate tool using the code snippet
10073     for ac_prog in sort
10074 do
10075   # Extract the first word of "$ac_prog", so it can be a program name with args.
10076 set dummy $ac_prog; ac_word=$2
10077 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10078 $as_echo_n "checking for $ac_word... " >&6; }
10079 if ${ac_cv_path_SORT+:} false; then :
10080   $as_echo_n "(cached) " >&6
10081 else
10082   case $SORT in
10083   [\\/]* | ?:[\\/]*)
10084   ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
10085   ;;
10086   *)
10087   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10088 for as_dir in $PATH
10089 do
10090   IFS=$as_save_IFS
10091   test -z "$as_dir" && as_dir=.
10092     for ac_exec_ext in '' $ac_executable_extensions; do
10093   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10094     ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
10095     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10096     break 2
10097   fi
10098 done
10099   done
10100 IFS=$as_save_IFS
10101 
10102   ;;
10103 esac
10104 fi
10105 SORT=$ac_cv_path_SORT
10106 if test -n "$SORT"; then
10107   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
10108 $as_echo "$SORT" >&6; }
10109 else
10110   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10111 $as_echo "no" >&6; }
10112 fi
10113 
10114 
10115   test -n "$SORT" && break
10116 done
10117 
10118   else
10119     # The variable is set, but is it from the command line or the environment?
10120 
10121     # Try to remove the string !SORT! from our list.
10122     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SORT!/}
10123     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10124       # If it failed, the variable was not from the command line. Ignore it,
10125       # but warn the user (except for BASH, which is always set by the calling BASH).
10126       if test "xSORT" != xBASH; then
10127         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SORT from the environment. Use command line variables instead." >&5
10128 $as_echo "$as_me: WARNING: Ignoring value of SORT from the environment. Use command line variables instead." >&2;}
10129       fi
10130       # Try to locate tool using the code snippet
10131       for ac_prog in sort
10132 do
10133   # Extract the first word of "$ac_prog", so it can be a program name with args.
10134 set dummy $ac_prog; ac_word=$2
10135 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10136 $as_echo_n "checking for $ac_word... " >&6; }
10137 if ${ac_cv_path_SORT+:} false; then :
10138   $as_echo_n "(cached) " >&6
10139 else
10140   case $SORT in
10141   [\\/]* | ?:[\\/]*)
10142   ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
10143   ;;
10144   *)
10145   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10146 for as_dir in $PATH
10147 do
10148   IFS=$as_save_IFS
10149   test -z "$as_dir" && as_dir=.
10150     for ac_exec_ext in '' $ac_executable_extensions; do
10151   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10152     ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
10153     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10154     break 2
10155   fi
10156 done
10157   done
10158 IFS=$as_save_IFS
10159 
10160   ;;
10161 esac
10162 fi
10163 SORT=$ac_cv_path_SORT
10164 if test -n "$SORT"; then
10165   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
10166 $as_echo "$SORT" >&6; }
10167 else
10168   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10169 $as_echo "no" >&6; }
10170 fi
10171 
10172 
10173   test -n "$SORT" && break
10174 done
10175 
10176     else
10177       # If it succeeded, then it was overridden by the user. We will use it
10178       # for the tool.
10179 
10180       # First remove it from the list of overridden variables, so we can test
10181       # for unknown variables in the end.
10182       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10183 
10184       # Check if we try to supply an empty value
10185       if test "x$SORT" = x; then
10186         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool SORT= (no value)" >&5
10187 $as_echo "$as_me: Setting user supplied tool SORT= (no value)" >&6;}
10188         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SORT" >&5
10189 $as_echo_n "checking for SORT... " >&6; }
10190         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
10191 $as_echo "disabled" >&6; }
10192       else
10193         # Check if the provided tool contains a complete path.
10194         tool_specified="$SORT"
10195         tool_basename="${tool_specified##*/}"
10196         if test "x$tool_basename" = "x$tool_specified"; then
10197           # A command without a complete path is provided, search $PATH.
10198           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SORT=$tool_basename" >&5
10199 $as_echo "$as_me: Will search for user supplied tool SORT=$tool_basename" >&6;}
10200           # Extract the first word of "$tool_basename", so it can be a program name with args.
10201 set dummy $tool_basename; ac_word=$2
10202 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10203 $as_echo_n "checking for $ac_word... " >&6; }
10204 if ${ac_cv_path_SORT+:} false; then :
10205   $as_echo_n "(cached) " >&6
10206 else
10207   case $SORT in
10208   [\\/]* | ?:[\\/]*)
10209   ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
10210   ;;
10211   *)
10212   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10213 for as_dir in $PATH
10214 do
10215   IFS=$as_save_IFS
10216   test -z "$as_dir" && as_dir=.
10217     for ac_exec_ext in '' $ac_executable_extensions; do
10218   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10219     ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
10220     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10221     break 2
10222   fi
10223 done
10224   done
10225 IFS=$as_save_IFS
10226 
10227   ;;
10228 esac
10229 fi
10230 SORT=$ac_cv_path_SORT
10231 if test -n "$SORT"; then
10232   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
10233 $as_echo "$SORT" >&6; }
10234 else
10235   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10236 $as_echo "no" >&6; }
10237 fi
10238 
10239 
10240           if test "x$SORT" = x; then
10241             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10242           fi
10243         else
10244           # Otherwise we believe it is a complete path. Use it as it is.
10245           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SORT=$tool_specified" >&5
10246 $as_echo "$as_me: Will use user supplied tool SORT=$tool_specified" >&6;}
10247           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SORT" >&5
10248 $as_echo_n "checking for SORT... " >&6; }
10249           if test ! -x "$tool_specified"; then
10250             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10251 $as_echo "not found" >&6; }
10252             as_fn_error $? "User supplied tool SORT=$tool_specified does not exist or is not executable" "$LINENO" 5
10253           fi
10254           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10255 $as_echo "$tool_specified" >&6; }
10256         fi
10257       fi
10258     fi
10259 
10260   fi
10261 
10262 
10263 
10264   if test "x$SORT" = x; then
10265     as_fn_error $? "Could not find required tool for SORT" "$LINENO" 5
10266   fi
10267 
10268 
10269 
10270 
10271 
10272   # Publish this variable in the help.
10273 
10274 
10275   if [ -z "${TAIL+x}" ]; then
10276     # The variable is not set by user, try to locate tool using the code snippet
10277     for ac_prog in tail
10278 do
10279   # Extract the first word of "$ac_prog", so it can be a program name with args.
10280 set dummy $ac_prog; ac_word=$2
10281 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10282 $as_echo_n "checking for $ac_word... " >&6; }
10283 if ${ac_cv_path_TAIL+:} false; then :
10284   $as_echo_n "(cached) " >&6
10285 else
10286   case $TAIL in
10287   [\\/]* | ?:[\\/]*)
10288   ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
10289   ;;
10290   *)
10291   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10292 for as_dir in $PATH
10293 do
10294   IFS=$as_save_IFS
10295   test -z "$as_dir" && as_dir=.
10296     for ac_exec_ext in '' $ac_executable_extensions; do
10297   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10298     ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
10299     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10300     break 2
10301   fi
10302 done
10303   done
10304 IFS=$as_save_IFS
10305 
10306   ;;
10307 esac
10308 fi
10309 TAIL=$ac_cv_path_TAIL
10310 if test -n "$TAIL"; then
10311   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
10312 $as_echo "$TAIL" >&6; }
10313 else
10314   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10315 $as_echo "no" >&6; }
10316 fi
10317 
10318 
10319   test -n "$TAIL" && break
10320 done
10321 
10322   else
10323     # The variable is set, but is it from the command line or the environment?
10324 
10325     # Try to remove the string !TAIL! from our list.
10326     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TAIL!/}
10327     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10328       # If it failed, the variable was not from the command line. Ignore it,
10329       # but warn the user (except for BASH, which is always set by the calling BASH).
10330       if test "xTAIL" != xBASH; then
10331         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TAIL from the environment. Use command line variables instead." >&5
10332 $as_echo "$as_me: WARNING: Ignoring value of TAIL from the environment. Use command line variables instead." >&2;}
10333       fi
10334       # Try to locate tool using the code snippet
10335       for ac_prog in tail
10336 do
10337   # Extract the first word of "$ac_prog", so it can be a program name with args.
10338 set dummy $ac_prog; ac_word=$2
10339 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10340 $as_echo_n "checking for $ac_word... " >&6; }
10341 if ${ac_cv_path_TAIL+:} false; then :
10342   $as_echo_n "(cached) " >&6
10343 else
10344   case $TAIL in
10345   [\\/]* | ?:[\\/]*)
10346   ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
10347   ;;
10348   *)
10349   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10350 for as_dir in $PATH
10351 do
10352   IFS=$as_save_IFS
10353   test -z "$as_dir" && as_dir=.
10354     for ac_exec_ext in '' $ac_executable_extensions; do
10355   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10356     ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
10357     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10358     break 2
10359   fi
10360 done
10361   done
10362 IFS=$as_save_IFS
10363 
10364   ;;
10365 esac
10366 fi
10367 TAIL=$ac_cv_path_TAIL
10368 if test -n "$TAIL"; then
10369   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
10370 $as_echo "$TAIL" >&6; }
10371 else
10372   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10373 $as_echo "no" >&6; }
10374 fi
10375 
10376 
10377   test -n "$TAIL" && break
10378 done
10379 
10380     else
10381       # If it succeeded, then it was overridden by the user. We will use it
10382       # for the tool.
10383 
10384       # First remove it from the list of overridden variables, so we can test
10385       # for unknown variables in the end.
10386       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10387 
10388       # Check if we try to supply an empty value
10389       if test "x$TAIL" = x; then
10390         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool TAIL= (no value)" >&5
10391 $as_echo "$as_me: Setting user supplied tool TAIL= (no value)" >&6;}
10392         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAIL" >&5
10393 $as_echo_n "checking for TAIL... " >&6; }
10394         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
10395 $as_echo "disabled" >&6; }
10396       else
10397         # Check if the provided tool contains a complete path.
10398         tool_specified="$TAIL"
10399         tool_basename="${tool_specified##*/}"
10400         if test "x$tool_basename" = "x$tool_specified"; then
10401           # A command without a complete path is provided, search $PATH.
10402           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TAIL=$tool_basename" >&5
10403 $as_echo "$as_me: Will search for user supplied tool TAIL=$tool_basename" >&6;}
10404           # Extract the first word of "$tool_basename", so it can be a program name with args.
10405 set dummy $tool_basename; ac_word=$2
10406 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10407 $as_echo_n "checking for $ac_word... " >&6; }
10408 if ${ac_cv_path_TAIL+:} false; then :
10409   $as_echo_n "(cached) " >&6
10410 else
10411   case $TAIL in
10412   [\\/]* | ?:[\\/]*)
10413   ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
10414   ;;
10415   *)
10416   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10417 for as_dir in $PATH
10418 do
10419   IFS=$as_save_IFS
10420   test -z "$as_dir" && as_dir=.
10421     for ac_exec_ext in '' $ac_executable_extensions; do
10422   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10423     ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
10424     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10425     break 2
10426   fi
10427 done
10428   done
10429 IFS=$as_save_IFS
10430 
10431   ;;
10432 esac
10433 fi
10434 TAIL=$ac_cv_path_TAIL
10435 if test -n "$TAIL"; then
10436   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
10437 $as_echo "$TAIL" >&6; }
10438 else
10439   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10440 $as_echo "no" >&6; }
10441 fi
10442 
10443 
10444           if test "x$TAIL" = x; then
10445             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10446           fi
10447         else
10448           # Otherwise we believe it is a complete path. Use it as it is.
10449           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TAIL=$tool_specified" >&5
10450 $as_echo "$as_me: Will use user supplied tool TAIL=$tool_specified" >&6;}
10451           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAIL" >&5
10452 $as_echo_n "checking for TAIL... " >&6; }
10453           if test ! -x "$tool_specified"; then
10454             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10455 $as_echo "not found" >&6; }
10456             as_fn_error $? "User supplied tool TAIL=$tool_specified does not exist or is not executable" "$LINENO" 5
10457           fi
10458           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10459 $as_echo "$tool_specified" >&6; }
10460         fi
10461       fi
10462     fi
10463 
10464   fi
10465 
10466 
10467 
10468   if test "x$TAIL" = x; then
10469     as_fn_error $? "Could not find required tool for TAIL" "$LINENO" 5
10470   fi
10471 
10472 
10473 
10474 
10475 
10476   # Publish this variable in the help.
10477 
10478 
10479   if [ -z "${TAR+x}" ]; then
10480     # The variable is not set by user, try to locate tool using the code snippet
10481     for ac_prog in tar
10482 do
10483   # Extract the first word of "$ac_prog", so it can be a program name with args.
10484 set dummy $ac_prog; ac_word=$2
10485 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10486 $as_echo_n "checking for $ac_word... " >&6; }
10487 if ${ac_cv_path_TAR+:} false; then :
10488   $as_echo_n "(cached) " >&6
10489 else
10490   case $TAR in
10491   [\\/]* | ?:[\\/]*)
10492   ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
10493   ;;
10494   *)
10495   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10496 for as_dir in $PATH
10497 do
10498   IFS=$as_save_IFS
10499   test -z "$as_dir" && as_dir=.
10500     for ac_exec_ext in '' $ac_executable_extensions; do
10501   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10502     ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
10503     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10504     break 2
10505   fi
10506 done
10507   done
10508 IFS=$as_save_IFS
10509 
10510   ;;
10511 esac
10512 fi
10513 TAR=$ac_cv_path_TAR
10514 if test -n "$TAR"; then
10515   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
10516 $as_echo "$TAR" >&6; }
10517 else
10518   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10519 $as_echo "no" >&6; }
10520 fi
10521 
10522 
10523   test -n "$TAR" && break
10524 done
10525 
10526   else
10527     # The variable is set, but is it from the command line or the environment?
10528 
10529     # Try to remove the string !TAR! from our list.
10530     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TAR!/}
10531     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10532       # If it failed, the variable was not from the command line. Ignore it,
10533       # but warn the user (except for BASH, which is always set by the calling BASH).
10534       if test "xTAR" != xBASH; then
10535         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TAR from the environment. Use command line variables instead." >&5
10536 $as_echo "$as_me: WARNING: Ignoring value of TAR from the environment. Use command line variables instead." >&2;}
10537       fi
10538       # Try to locate tool using the code snippet
10539       for ac_prog in tar
10540 do
10541   # Extract the first word of "$ac_prog", so it can be a program name with args.
10542 set dummy $ac_prog; ac_word=$2
10543 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10544 $as_echo_n "checking for $ac_word... " >&6; }
10545 if ${ac_cv_path_TAR+:} false; then :
10546   $as_echo_n "(cached) " >&6
10547 else
10548   case $TAR in
10549   [\\/]* | ?:[\\/]*)
10550   ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
10551   ;;
10552   *)
10553   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10554 for as_dir in $PATH
10555 do
10556   IFS=$as_save_IFS
10557   test -z "$as_dir" && as_dir=.
10558     for ac_exec_ext in '' $ac_executable_extensions; do
10559   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10560     ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
10561     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10562     break 2
10563   fi
10564 done
10565   done
10566 IFS=$as_save_IFS
10567 
10568   ;;
10569 esac
10570 fi
10571 TAR=$ac_cv_path_TAR
10572 if test -n "$TAR"; then
10573   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
10574 $as_echo "$TAR" >&6; }
10575 else
10576   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10577 $as_echo "no" >&6; }
10578 fi
10579 
10580 
10581   test -n "$TAR" && break
10582 done
10583 
10584     else
10585       # If it succeeded, then it was overridden by the user. We will use it
10586       # for the tool.
10587 
10588       # First remove it from the list of overridden variables, so we can test
10589       # for unknown variables in the end.
10590       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10591 
10592       # Check if we try to supply an empty value
10593       if test "x$TAR" = x; then
10594         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool TAR= (no value)" >&5
10595 $as_echo "$as_me: Setting user supplied tool TAR= (no value)" >&6;}
10596         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAR" >&5
10597 $as_echo_n "checking for TAR... " >&6; }
10598         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
10599 $as_echo "disabled" >&6; }
10600       else
10601         # Check if the provided tool contains a complete path.
10602         tool_specified="$TAR"
10603         tool_basename="${tool_specified##*/}"
10604         if test "x$tool_basename" = "x$tool_specified"; then
10605           # A command without a complete path is provided, search $PATH.
10606           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TAR=$tool_basename" >&5
10607 $as_echo "$as_me: Will search for user supplied tool TAR=$tool_basename" >&6;}
10608           # Extract the first word of "$tool_basename", so it can be a program name with args.
10609 set dummy $tool_basename; ac_word=$2
10610 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10611 $as_echo_n "checking for $ac_word... " >&6; }
10612 if ${ac_cv_path_TAR+:} false; then :
10613   $as_echo_n "(cached) " >&6
10614 else
10615   case $TAR in
10616   [\\/]* | ?:[\\/]*)
10617   ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
10618   ;;
10619   *)
10620   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10621 for as_dir in $PATH
10622 do
10623   IFS=$as_save_IFS
10624   test -z "$as_dir" && as_dir=.
10625     for ac_exec_ext in '' $ac_executable_extensions; do
10626   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10627     ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
10628     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10629     break 2
10630   fi
10631 done
10632   done
10633 IFS=$as_save_IFS
10634 
10635   ;;
10636 esac
10637 fi
10638 TAR=$ac_cv_path_TAR
10639 if test -n "$TAR"; then
10640   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
10641 $as_echo "$TAR" >&6; }
10642 else
10643   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10644 $as_echo "no" >&6; }
10645 fi
10646 
10647 
10648           if test "x$TAR" = x; then
10649             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10650           fi
10651         else
10652           # Otherwise we believe it is a complete path. Use it as it is.
10653           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TAR=$tool_specified" >&5
10654 $as_echo "$as_me: Will use user supplied tool TAR=$tool_specified" >&6;}
10655           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAR" >&5
10656 $as_echo_n "checking for TAR... " >&6; }
10657           if test ! -x "$tool_specified"; then
10658             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10659 $as_echo "not found" >&6; }
10660             as_fn_error $? "User supplied tool TAR=$tool_specified does not exist or is not executable" "$LINENO" 5
10661           fi
10662           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10663 $as_echo "$tool_specified" >&6; }
10664         fi
10665       fi
10666     fi
10667 
10668   fi
10669 
10670 
10671 
10672   if test "x$TAR" = x; then
10673     as_fn_error $? "Could not find required tool for TAR" "$LINENO" 5
10674   fi
10675 
10676 
10677 
10678 
10679 
10680   # Publish this variable in the help.
10681 
10682 
10683   if [ -z "${TEE+x}" ]; then
10684     # The variable is not set by user, try to locate tool using the code snippet
10685     for ac_prog in tee
10686 do
10687   # Extract the first word of "$ac_prog", so it can be a program name with args.
10688 set dummy $ac_prog; ac_word=$2
10689 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10690 $as_echo_n "checking for $ac_word... " >&6; }
10691 if ${ac_cv_path_TEE+:} false; then :
10692   $as_echo_n "(cached) " >&6
10693 else
10694   case $TEE in
10695   [\\/]* | ?:[\\/]*)
10696   ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
10697   ;;
10698   *)
10699   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10700 for as_dir in $PATH
10701 do
10702   IFS=$as_save_IFS
10703   test -z "$as_dir" && as_dir=.
10704     for ac_exec_ext in '' $ac_executable_extensions; do
10705   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10706     ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
10707     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10708     break 2
10709   fi
10710 done
10711   done
10712 IFS=$as_save_IFS
10713 
10714   ;;
10715 esac
10716 fi
10717 TEE=$ac_cv_path_TEE
10718 if test -n "$TEE"; then
10719   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
10720 $as_echo "$TEE" >&6; }
10721 else
10722   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10723 $as_echo "no" >&6; }
10724 fi
10725 
10726 
10727   test -n "$TEE" && break
10728 done
10729 
10730   else
10731     # The variable is set, but is it from the command line or the environment?
10732 
10733     # Try to remove the string !TEE! from our list.
10734     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TEE!/}
10735     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10736       # If it failed, the variable was not from the command line. Ignore it,
10737       # but warn the user (except for BASH, which is always set by the calling BASH).
10738       if test "xTEE" != xBASH; then
10739         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TEE from the environment. Use command line variables instead." >&5
10740 $as_echo "$as_me: WARNING: Ignoring value of TEE from the environment. Use command line variables instead." >&2;}
10741       fi
10742       # Try to locate tool using the code snippet
10743       for ac_prog in tee
10744 do
10745   # Extract the first word of "$ac_prog", so it can be a program name with args.
10746 set dummy $ac_prog; ac_word=$2
10747 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10748 $as_echo_n "checking for $ac_word... " >&6; }
10749 if ${ac_cv_path_TEE+:} false; then :
10750   $as_echo_n "(cached) " >&6
10751 else
10752   case $TEE in
10753   [\\/]* | ?:[\\/]*)
10754   ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
10755   ;;
10756   *)
10757   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10758 for as_dir in $PATH
10759 do
10760   IFS=$as_save_IFS
10761   test -z "$as_dir" && as_dir=.
10762     for ac_exec_ext in '' $ac_executable_extensions; do
10763   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10764     ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
10765     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10766     break 2
10767   fi
10768 done
10769   done
10770 IFS=$as_save_IFS
10771 
10772   ;;
10773 esac
10774 fi
10775 TEE=$ac_cv_path_TEE
10776 if test -n "$TEE"; then
10777   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
10778 $as_echo "$TEE" >&6; }
10779 else
10780   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10781 $as_echo "no" >&6; }
10782 fi
10783 
10784 
10785   test -n "$TEE" && break
10786 done
10787 
10788     else
10789       # If it succeeded, then it was overridden by the user. We will use it
10790       # for the tool.
10791 
10792       # First remove it from the list of overridden variables, so we can test
10793       # for unknown variables in the end.
10794       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10795 
10796       # Check if we try to supply an empty value
10797       if test "x$TEE" = x; then
10798         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool TEE= (no value)" >&5
10799 $as_echo "$as_me: Setting user supplied tool TEE= (no value)" >&6;}
10800         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TEE" >&5
10801 $as_echo_n "checking for TEE... " >&6; }
10802         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
10803 $as_echo "disabled" >&6; }
10804       else
10805         # Check if the provided tool contains a complete path.
10806         tool_specified="$TEE"
10807         tool_basename="${tool_specified##*/}"
10808         if test "x$tool_basename" = "x$tool_specified"; then
10809           # A command without a complete path is provided, search $PATH.
10810           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TEE=$tool_basename" >&5
10811 $as_echo "$as_me: Will search for user supplied tool TEE=$tool_basename" >&6;}
10812           # Extract the first word of "$tool_basename", so it can be a program name with args.
10813 set dummy $tool_basename; ac_word=$2
10814 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10815 $as_echo_n "checking for $ac_word... " >&6; }
10816 if ${ac_cv_path_TEE+:} false; then :
10817   $as_echo_n "(cached) " >&6
10818 else
10819   case $TEE in
10820   [\\/]* | ?:[\\/]*)
10821   ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
10822   ;;
10823   *)
10824   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10825 for as_dir in $PATH
10826 do
10827   IFS=$as_save_IFS
10828   test -z "$as_dir" && as_dir=.
10829     for ac_exec_ext in '' $ac_executable_extensions; do
10830   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10831     ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
10832     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10833     break 2
10834   fi
10835 done
10836   done
10837 IFS=$as_save_IFS
10838 
10839   ;;
10840 esac
10841 fi
10842 TEE=$ac_cv_path_TEE
10843 if test -n "$TEE"; then
10844   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
10845 $as_echo "$TEE" >&6; }
10846 else
10847   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10848 $as_echo "no" >&6; }
10849 fi
10850 
10851 
10852           if test "x$TEE" = x; then
10853             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10854           fi
10855         else
10856           # Otherwise we believe it is a complete path. Use it as it is.
10857           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TEE=$tool_specified" >&5
10858 $as_echo "$as_me: Will use user supplied tool TEE=$tool_specified" >&6;}
10859           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TEE" >&5
10860 $as_echo_n "checking for TEE... " >&6; }
10861           if test ! -x "$tool_specified"; then
10862             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10863 $as_echo "not found" >&6; }
10864             as_fn_error $? "User supplied tool TEE=$tool_specified does not exist or is not executable" "$LINENO" 5
10865           fi
10866           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10867 $as_echo "$tool_specified" >&6; }
10868         fi
10869       fi
10870     fi
10871 
10872   fi
10873 
10874 
10875 
10876   if test "x$TEE" = x; then
10877     as_fn_error $? "Could not find required tool for TEE" "$LINENO" 5
10878   fi
10879 
10880 
10881 
10882 
10883 
10884   # Publish this variable in the help.
10885 
10886 
10887   if [ -z "${TOUCH+x}" ]; then
10888     # The variable is not set by user, try to locate tool using the code snippet
10889     for ac_prog in touch
10890 do
10891   # Extract the first word of "$ac_prog", so it can be a program name with args.
10892 set dummy $ac_prog; ac_word=$2
10893 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10894 $as_echo_n "checking for $ac_word... " >&6; }
10895 if ${ac_cv_path_TOUCH+:} false; then :
10896   $as_echo_n "(cached) " >&6
10897 else
10898   case $TOUCH in
10899   [\\/]* | ?:[\\/]*)
10900   ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
10901   ;;
10902   *)
10903   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10904 for as_dir in $PATH
10905 do
10906   IFS=$as_save_IFS
10907   test -z "$as_dir" && as_dir=.
10908     for ac_exec_ext in '' $ac_executable_extensions; do
10909   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10910     ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
10911     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10912     break 2
10913   fi
10914 done
10915   done
10916 IFS=$as_save_IFS
10917 
10918   ;;
10919 esac
10920 fi
10921 TOUCH=$ac_cv_path_TOUCH
10922 if test -n "$TOUCH"; then
10923   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
10924 $as_echo "$TOUCH" >&6; }
10925 else
10926   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10927 $as_echo "no" >&6; }
10928 fi
10929 
10930 
10931   test -n "$TOUCH" && break
10932 done
10933 
10934   else
10935     # The variable is set, but is it from the command line or the environment?
10936 
10937     # Try to remove the string !TOUCH! from our list.
10938     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TOUCH!/}
10939     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10940       # If it failed, the variable was not from the command line. Ignore it,
10941       # but warn the user (except for BASH, which is always set by the calling BASH).
10942       if test "xTOUCH" != xBASH; then
10943         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TOUCH from the environment. Use command line variables instead." >&5
10944 $as_echo "$as_me: WARNING: Ignoring value of TOUCH from the environment. Use command line variables instead." >&2;}
10945       fi
10946       # Try to locate tool using the code snippet
10947       for ac_prog in touch
10948 do
10949   # Extract the first word of "$ac_prog", so it can be a program name with args.
10950 set dummy $ac_prog; ac_word=$2
10951 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10952 $as_echo_n "checking for $ac_word... " >&6; }
10953 if ${ac_cv_path_TOUCH+:} false; then :
10954   $as_echo_n "(cached) " >&6
10955 else
10956   case $TOUCH in
10957   [\\/]* | ?:[\\/]*)
10958   ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
10959   ;;
10960   *)
10961   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10962 for as_dir in $PATH
10963 do
10964   IFS=$as_save_IFS
10965   test -z "$as_dir" && as_dir=.
10966     for ac_exec_ext in '' $ac_executable_extensions; do
10967   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10968     ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
10969     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10970     break 2
10971   fi
10972 done
10973   done
10974 IFS=$as_save_IFS
10975 
10976   ;;
10977 esac
10978 fi
10979 TOUCH=$ac_cv_path_TOUCH
10980 if test -n "$TOUCH"; then
10981   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
10982 $as_echo "$TOUCH" >&6; }
10983 else
10984   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10985 $as_echo "no" >&6; }
10986 fi
10987 
10988 
10989   test -n "$TOUCH" && break
10990 done
10991 
10992     else
10993       # If it succeeded, then it was overridden by the user. We will use it
10994       # for the tool.
10995 
10996       # First remove it from the list of overridden variables, so we can test
10997       # for unknown variables in the end.
10998       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10999 
11000       # Check if we try to supply an empty value
11001       if test "x$TOUCH" = x; then
11002         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool TOUCH= (no value)" >&5
11003 $as_echo "$as_me: Setting user supplied tool TOUCH= (no value)" >&6;}
11004         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TOUCH" >&5
11005 $as_echo_n "checking for TOUCH... " >&6; }
11006         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
11007 $as_echo "disabled" >&6; }
11008       else
11009         # Check if the provided tool contains a complete path.
11010         tool_specified="$TOUCH"
11011         tool_basename="${tool_specified##*/}"
11012         if test "x$tool_basename" = "x$tool_specified"; then
11013           # A command without a complete path is provided, search $PATH.
11014           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TOUCH=$tool_basename" >&5
11015 $as_echo "$as_me: Will search for user supplied tool TOUCH=$tool_basename" >&6;}
11016           # Extract the first word of "$tool_basename", so it can be a program name with args.
11017 set dummy $tool_basename; ac_word=$2
11018 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11019 $as_echo_n "checking for $ac_word... " >&6; }
11020 if ${ac_cv_path_TOUCH+:} false; then :
11021   $as_echo_n "(cached) " >&6
11022 else
11023   case $TOUCH in
11024   [\\/]* | ?:[\\/]*)
11025   ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
11026   ;;
11027   *)
11028   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11029 for as_dir in $PATH
11030 do
11031   IFS=$as_save_IFS
11032   test -z "$as_dir" && as_dir=.
11033     for ac_exec_ext in '' $ac_executable_extensions; do
11034   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11035     ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
11036     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11037     break 2
11038   fi
11039 done
11040   done
11041 IFS=$as_save_IFS
11042 
11043   ;;
11044 esac
11045 fi
11046 TOUCH=$ac_cv_path_TOUCH
11047 if test -n "$TOUCH"; then
11048   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
11049 $as_echo "$TOUCH" >&6; }
11050 else
11051   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11052 $as_echo "no" >&6; }
11053 fi
11054 
11055 
11056           if test "x$TOUCH" = x; then
11057             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11058           fi
11059         else
11060           # Otherwise we believe it is a complete path. Use it as it is.
11061           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TOUCH=$tool_specified" >&5
11062 $as_echo "$as_me: Will use user supplied tool TOUCH=$tool_specified" >&6;}
11063           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TOUCH" >&5
11064 $as_echo_n "checking for TOUCH... " >&6; }
11065           if test ! -x "$tool_specified"; then
11066             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11067 $as_echo "not found" >&6; }
11068             as_fn_error $? "User supplied tool TOUCH=$tool_specified does not exist or is not executable" "$LINENO" 5
11069           fi
11070           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11071 $as_echo "$tool_specified" >&6; }
11072         fi
11073       fi
11074     fi
11075 
11076   fi
11077 
11078 
11079 
11080   if test "x$TOUCH" = x; then
11081     as_fn_error $? "Could not find required tool for TOUCH" "$LINENO" 5
11082   fi
11083 
11084 
11085 
11086 
11087 
11088   # Publish this variable in the help.
11089 
11090 
11091   if [ -z "${TR+x}" ]; then
11092     # The variable is not set by user, try to locate tool using the code snippet
11093     for ac_prog in tr
11094 do
11095   # Extract the first word of "$ac_prog", so it can be a program name with args.
11096 set dummy $ac_prog; ac_word=$2
11097 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11098 $as_echo_n "checking for $ac_word... " >&6; }
11099 if ${ac_cv_path_TR+:} false; then :
11100   $as_echo_n "(cached) " >&6
11101 else
11102   case $TR in
11103   [\\/]* | ?:[\\/]*)
11104   ac_cv_path_TR="$TR" # Let the user override the test with a path.
11105   ;;
11106   *)
11107   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11108 for as_dir in $PATH
11109 do
11110   IFS=$as_save_IFS
11111   test -z "$as_dir" && as_dir=.
11112     for ac_exec_ext in '' $ac_executable_extensions; do
11113   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11114     ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
11115     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11116     break 2
11117   fi
11118 done
11119   done
11120 IFS=$as_save_IFS
11121 
11122   ;;
11123 esac
11124 fi
11125 TR=$ac_cv_path_TR
11126 if test -n "$TR"; then
11127   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
11128 $as_echo "$TR" >&6; }
11129 else
11130   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11131 $as_echo "no" >&6; }
11132 fi
11133 
11134 
11135   test -n "$TR" && break
11136 done
11137 
11138   else
11139     # The variable is set, but is it from the command line or the environment?
11140 
11141     # Try to remove the string !TR! from our list.
11142     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TR!/}
11143     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11144       # If it failed, the variable was not from the command line. Ignore it,
11145       # but warn the user (except for BASH, which is always set by the calling BASH).
11146       if test "xTR" != xBASH; then
11147         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TR from the environment. Use command line variables instead." >&5
11148 $as_echo "$as_me: WARNING: Ignoring value of TR from the environment. Use command line variables instead." >&2;}
11149       fi
11150       # Try to locate tool using the code snippet
11151       for ac_prog in tr
11152 do
11153   # Extract the first word of "$ac_prog", so it can be a program name with args.
11154 set dummy $ac_prog; ac_word=$2
11155 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11156 $as_echo_n "checking for $ac_word... " >&6; }
11157 if ${ac_cv_path_TR+:} false; then :
11158   $as_echo_n "(cached) " >&6
11159 else
11160   case $TR in
11161   [\\/]* | ?:[\\/]*)
11162   ac_cv_path_TR="$TR" # Let the user override the test with a path.
11163   ;;
11164   *)
11165   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11166 for as_dir in $PATH
11167 do
11168   IFS=$as_save_IFS
11169   test -z "$as_dir" && as_dir=.
11170     for ac_exec_ext in '' $ac_executable_extensions; do
11171   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11172     ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
11173     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11174     break 2
11175   fi
11176 done
11177   done
11178 IFS=$as_save_IFS
11179 
11180   ;;
11181 esac
11182 fi
11183 TR=$ac_cv_path_TR
11184 if test -n "$TR"; then
11185   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
11186 $as_echo "$TR" >&6; }
11187 else
11188   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11189 $as_echo "no" >&6; }
11190 fi
11191 
11192 
11193   test -n "$TR" && break
11194 done
11195 
11196     else
11197       # If it succeeded, then it was overridden by the user. We will use it
11198       # for the tool.
11199 
11200       # First remove it from the list of overridden variables, so we can test
11201       # for unknown variables in the end.
11202       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11203 
11204       # Check if we try to supply an empty value
11205       if test "x$TR" = x; then
11206         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool TR= (no value)" >&5
11207 $as_echo "$as_me: Setting user supplied tool TR= (no value)" >&6;}
11208         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TR" >&5
11209 $as_echo_n "checking for TR... " >&6; }
11210         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
11211 $as_echo "disabled" >&6; }
11212       else
11213         # Check if the provided tool contains a complete path.
11214         tool_specified="$TR"
11215         tool_basename="${tool_specified##*/}"
11216         if test "x$tool_basename" = "x$tool_specified"; then
11217           # A command without a complete path is provided, search $PATH.
11218           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TR=$tool_basename" >&5
11219 $as_echo "$as_me: Will search for user supplied tool TR=$tool_basename" >&6;}
11220           # Extract the first word of "$tool_basename", so it can be a program name with args.
11221 set dummy $tool_basename; ac_word=$2
11222 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11223 $as_echo_n "checking for $ac_word... " >&6; }
11224 if ${ac_cv_path_TR+:} false; then :
11225   $as_echo_n "(cached) " >&6
11226 else
11227   case $TR in
11228   [\\/]* | ?:[\\/]*)
11229   ac_cv_path_TR="$TR" # Let the user override the test with a path.
11230   ;;
11231   *)
11232   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11233 for as_dir in $PATH
11234 do
11235   IFS=$as_save_IFS
11236   test -z "$as_dir" && as_dir=.
11237     for ac_exec_ext in '' $ac_executable_extensions; do
11238   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11239     ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
11240     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11241     break 2
11242   fi
11243 done
11244   done
11245 IFS=$as_save_IFS
11246 
11247   ;;
11248 esac
11249 fi
11250 TR=$ac_cv_path_TR
11251 if test -n "$TR"; then
11252   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
11253 $as_echo "$TR" >&6; }
11254 else
11255   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11256 $as_echo "no" >&6; }
11257 fi
11258 
11259 
11260           if test "x$TR" = x; then
11261             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11262           fi
11263         else
11264           # Otherwise we believe it is a complete path. Use it as it is.
11265           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TR=$tool_specified" >&5
11266 $as_echo "$as_me: Will use user supplied tool TR=$tool_specified" >&6;}
11267           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TR" >&5
11268 $as_echo_n "checking for TR... " >&6; }
11269           if test ! -x "$tool_specified"; then
11270             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11271 $as_echo "not found" >&6; }
11272             as_fn_error $? "User supplied tool TR=$tool_specified does not exist or is not executable" "$LINENO" 5
11273           fi
11274           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11275 $as_echo "$tool_specified" >&6; }
11276         fi
11277       fi
11278     fi
11279 
11280   fi
11281 
11282 
11283 
11284   if test "x$TR" = x; then
11285     as_fn_error $? "Could not find required tool for TR" "$LINENO" 5
11286   fi
11287 
11288 
11289 
11290 
11291 
11292   # Publish this variable in the help.
11293 
11294 
11295   if [ -z "${UNAME+x}" ]; then
11296     # The variable is not set by user, try to locate tool using the code snippet
11297     for ac_prog in uname
11298 do
11299   # Extract the first word of "$ac_prog", so it can be a program name with args.
11300 set dummy $ac_prog; ac_word=$2
11301 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11302 $as_echo_n "checking for $ac_word... " >&6; }
11303 if ${ac_cv_path_UNAME+:} false; then :
11304   $as_echo_n "(cached) " >&6
11305 else
11306   case $UNAME in
11307   [\\/]* | ?:[\\/]*)
11308   ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
11309   ;;
11310   *)
11311   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11312 for as_dir in $PATH
11313 do
11314   IFS=$as_save_IFS
11315   test -z "$as_dir" && as_dir=.
11316     for ac_exec_ext in '' $ac_executable_extensions; do
11317   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11318     ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
11319     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11320     break 2
11321   fi
11322 done
11323   done
11324 IFS=$as_save_IFS
11325 
11326   ;;
11327 esac
11328 fi
11329 UNAME=$ac_cv_path_UNAME
11330 if test -n "$UNAME"; then
11331   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
11332 $as_echo "$UNAME" >&6; }
11333 else
11334   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11335 $as_echo "no" >&6; }
11336 fi
11337 
11338 
11339   test -n "$UNAME" && break
11340 done
11341 
11342   else
11343     # The variable is set, but is it from the command line or the environment?
11344 
11345     # Try to remove the string !UNAME! from our list.
11346     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNAME!/}
11347     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11348       # If it failed, the variable was not from the command line. Ignore it,
11349       # but warn the user (except for BASH, which is always set by the calling BASH).
11350       if test "xUNAME" != xBASH; then
11351         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNAME from the environment. Use command line variables instead." >&5
11352 $as_echo "$as_me: WARNING: Ignoring value of UNAME from the environment. Use command line variables instead." >&2;}
11353       fi
11354       # Try to locate tool using the code snippet
11355       for ac_prog in uname
11356 do
11357   # Extract the first word of "$ac_prog", so it can be a program name with args.
11358 set dummy $ac_prog; ac_word=$2
11359 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11360 $as_echo_n "checking for $ac_word... " >&6; }
11361 if ${ac_cv_path_UNAME+:} false; then :
11362   $as_echo_n "(cached) " >&6
11363 else
11364   case $UNAME in
11365   [\\/]* | ?:[\\/]*)
11366   ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
11367   ;;
11368   *)
11369   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11370 for as_dir in $PATH
11371 do
11372   IFS=$as_save_IFS
11373   test -z "$as_dir" && as_dir=.
11374     for ac_exec_ext in '' $ac_executable_extensions; do
11375   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11376     ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
11377     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11378     break 2
11379   fi
11380 done
11381   done
11382 IFS=$as_save_IFS
11383 
11384   ;;
11385 esac
11386 fi
11387 UNAME=$ac_cv_path_UNAME
11388 if test -n "$UNAME"; then
11389   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
11390 $as_echo "$UNAME" >&6; }
11391 else
11392   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11393 $as_echo "no" >&6; }
11394 fi
11395 
11396 
11397   test -n "$UNAME" && break
11398 done
11399 
11400     else
11401       # If it succeeded, then it was overridden by the user. We will use it
11402       # for the tool.
11403 
11404       # First remove it from the list of overridden variables, so we can test
11405       # for unknown variables in the end.
11406       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11407 
11408       # Check if we try to supply an empty value
11409       if test "x$UNAME" = x; then
11410         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool UNAME= (no value)" >&5
11411 $as_echo "$as_me: Setting user supplied tool UNAME= (no value)" >&6;}
11412         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNAME" >&5
11413 $as_echo_n "checking for UNAME... " >&6; }
11414         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
11415 $as_echo "disabled" >&6; }
11416       else
11417         # Check if the provided tool contains a complete path.
11418         tool_specified="$UNAME"
11419         tool_basename="${tool_specified##*/}"
11420         if test "x$tool_basename" = "x$tool_specified"; then
11421           # A command without a complete path is provided, search $PATH.
11422           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNAME=$tool_basename" >&5
11423 $as_echo "$as_me: Will search for user supplied tool UNAME=$tool_basename" >&6;}
11424           # Extract the first word of "$tool_basename", so it can be a program name with args.
11425 set dummy $tool_basename; ac_word=$2
11426 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11427 $as_echo_n "checking for $ac_word... " >&6; }
11428 if ${ac_cv_path_UNAME+:} false; then :
11429   $as_echo_n "(cached) " >&6
11430 else
11431   case $UNAME in
11432   [\\/]* | ?:[\\/]*)
11433   ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
11434   ;;
11435   *)
11436   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11437 for as_dir in $PATH
11438 do
11439   IFS=$as_save_IFS
11440   test -z "$as_dir" && as_dir=.
11441     for ac_exec_ext in '' $ac_executable_extensions; do
11442   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11443     ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
11444     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11445     break 2
11446   fi
11447 done
11448   done
11449 IFS=$as_save_IFS
11450 
11451   ;;
11452 esac
11453 fi
11454 UNAME=$ac_cv_path_UNAME
11455 if test -n "$UNAME"; then
11456   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
11457 $as_echo "$UNAME" >&6; }
11458 else
11459   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11460 $as_echo "no" >&6; }
11461 fi
11462 
11463 
11464           if test "x$UNAME" = x; then
11465             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11466           fi
11467         else
11468           # Otherwise we believe it is a complete path. Use it as it is.
11469           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNAME=$tool_specified" >&5
11470 $as_echo "$as_me: Will use user supplied tool UNAME=$tool_specified" >&6;}
11471           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNAME" >&5
11472 $as_echo_n "checking for UNAME... " >&6; }
11473           if test ! -x "$tool_specified"; then
11474             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11475 $as_echo "not found" >&6; }
11476             as_fn_error $? "User supplied tool UNAME=$tool_specified does not exist or is not executable" "$LINENO" 5
11477           fi
11478           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11479 $as_echo "$tool_specified" >&6; }
11480         fi
11481       fi
11482     fi
11483 
11484   fi
11485 
11486 
11487 
11488   if test "x$UNAME" = x; then
11489     as_fn_error $? "Could not find required tool for UNAME" "$LINENO" 5
11490   fi
11491 
11492 
11493 
11494 
11495 
11496   # Publish this variable in the help.
11497 
11498 
11499   if [ -z "${UNIQ+x}" ]; then
11500     # The variable is not set by user, try to locate tool using the code snippet
11501     for ac_prog in uniq
11502 do
11503   # Extract the first word of "$ac_prog", so it can be a program name with args.
11504 set dummy $ac_prog; ac_word=$2
11505 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11506 $as_echo_n "checking for $ac_word... " >&6; }
11507 if ${ac_cv_path_UNIQ+:} false; then :
11508   $as_echo_n "(cached) " >&6
11509 else
11510   case $UNIQ in
11511   [\\/]* | ?:[\\/]*)
11512   ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
11513   ;;
11514   *)
11515   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11516 for as_dir in $PATH
11517 do
11518   IFS=$as_save_IFS
11519   test -z "$as_dir" && as_dir=.
11520     for ac_exec_ext in '' $ac_executable_extensions; do
11521   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11522     ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
11523     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11524     break 2
11525   fi
11526 done
11527   done
11528 IFS=$as_save_IFS
11529 
11530   ;;
11531 esac
11532 fi
11533 UNIQ=$ac_cv_path_UNIQ
11534 if test -n "$UNIQ"; then
11535   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
11536 $as_echo "$UNIQ" >&6; }
11537 else
11538   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11539 $as_echo "no" >&6; }
11540 fi
11541 
11542 
11543   test -n "$UNIQ" && break
11544 done
11545 
11546   else
11547     # The variable is set, but is it from the command line or the environment?
11548 
11549     # Try to remove the string !UNIQ! from our list.
11550     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNIQ!/}
11551     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11552       # If it failed, the variable was not from the command line. Ignore it,
11553       # but warn the user (except for BASH, which is always set by the calling BASH).
11554       if test "xUNIQ" != xBASH; then
11555         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNIQ from the environment. Use command line variables instead." >&5
11556 $as_echo "$as_me: WARNING: Ignoring value of UNIQ from the environment. Use command line variables instead." >&2;}
11557       fi
11558       # Try to locate tool using the code snippet
11559       for ac_prog in uniq
11560 do
11561   # Extract the first word of "$ac_prog", so it can be a program name with args.
11562 set dummy $ac_prog; ac_word=$2
11563 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11564 $as_echo_n "checking for $ac_word... " >&6; }
11565 if ${ac_cv_path_UNIQ+:} false; then :
11566   $as_echo_n "(cached) " >&6
11567 else
11568   case $UNIQ in
11569   [\\/]* | ?:[\\/]*)
11570   ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
11571   ;;
11572   *)
11573   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11574 for as_dir in $PATH
11575 do
11576   IFS=$as_save_IFS
11577   test -z "$as_dir" && as_dir=.
11578     for ac_exec_ext in '' $ac_executable_extensions; do
11579   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11580     ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
11581     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11582     break 2
11583   fi
11584 done
11585   done
11586 IFS=$as_save_IFS
11587 
11588   ;;
11589 esac
11590 fi
11591 UNIQ=$ac_cv_path_UNIQ
11592 if test -n "$UNIQ"; then
11593   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
11594 $as_echo "$UNIQ" >&6; }
11595 else
11596   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11597 $as_echo "no" >&6; }
11598 fi
11599 
11600 
11601   test -n "$UNIQ" && break
11602 done
11603 
11604     else
11605       # If it succeeded, then it was overridden by the user. We will use it
11606       # for the tool.
11607 
11608       # First remove it from the list of overridden variables, so we can test
11609       # for unknown variables in the end.
11610       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11611 
11612       # Check if we try to supply an empty value
11613       if test "x$UNIQ" = x; then
11614         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool UNIQ= (no value)" >&5
11615 $as_echo "$as_me: Setting user supplied tool UNIQ= (no value)" >&6;}
11616         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNIQ" >&5
11617 $as_echo_n "checking for UNIQ... " >&6; }
11618         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
11619 $as_echo "disabled" >&6; }
11620       else
11621         # Check if the provided tool contains a complete path.
11622         tool_specified="$UNIQ"
11623         tool_basename="${tool_specified##*/}"
11624         if test "x$tool_basename" = "x$tool_specified"; then
11625           # A command without a complete path is provided, search $PATH.
11626           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNIQ=$tool_basename" >&5
11627 $as_echo "$as_me: Will search for user supplied tool UNIQ=$tool_basename" >&6;}
11628           # Extract the first word of "$tool_basename", so it can be a program name with args.
11629 set dummy $tool_basename; ac_word=$2
11630 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11631 $as_echo_n "checking for $ac_word... " >&6; }
11632 if ${ac_cv_path_UNIQ+:} false; then :
11633   $as_echo_n "(cached) " >&6
11634 else
11635   case $UNIQ in
11636   [\\/]* | ?:[\\/]*)
11637   ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
11638   ;;
11639   *)
11640   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11641 for as_dir in $PATH
11642 do
11643   IFS=$as_save_IFS
11644   test -z "$as_dir" && as_dir=.
11645     for ac_exec_ext in '' $ac_executable_extensions; do
11646   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11647     ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
11648     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11649     break 2
11650   fi
11651 done
11652   done
11653 IFS=$as_save_IFS
11654 
11655   ;;
11656 esac
11657 fi
11658 UNIQ=$ac_cv_path_UNIQ
11659 if test -n "$UNIQ"; then
11660   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
11661 $as_echo "$UNIQ" >&6; }
11662 else
11663   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11664 $as_echo "no" >&6; }
11665 fi
11666 
11667 
11668           if test "x$UNIQ" = x; then
11669             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11670           fi
11671         else
11672           # Otherwise we believe it is a complete path. Use it as it is.
11673           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNIQ=$tool_specified" >&5
11674 $as_echo "$as_me: Will use user supplied tool UNIQ=$tool_specified" >&6;}
11675           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNIQ" >&5
11676 $as_echo_n "checking for UNIQ... " >&6; }
11677           if test ! -x "$tool_specified"; then
11678             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11679 $as_echo "not found" >&6; }
11680             as_fn_error $? "User supplied tool UNIQ=$tool_specified does not exist or is not executable" "$LINENO" 5
11681           fi
11682           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11683 $as_echo "$tool_specified" >&6; }
11684         fi
11685       fi
11686     fi
11687 
11688   fi
11689 
11690 
11691 
11692   if test "x$UNIQ" = x; then
11693     as_fn_error $? "Could not find required tool for UNIQ" "$LINENO" 5
11694   fi
11695 
11696 
11697 
11698 
11699 
11700   # Publish this variable in the help.
11701 
11702 
11703   if [ -z "${WC+x}" ]; then
11704     # The variable is not set by user, try to locate tool using the code snippet
11705     for ac_prog in wc
11706 do
11707   # Extract the first word of "$ac_prog", so it can be a program name with args.
11708 set dummy $ac_prog; ac_word=$2
11709 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11710 $as_echo_n "checking for $ac_word... " >&6; }
11711 if ${ac_cv_path_WC+:} false; then :
11712   $as_echo_n "(cached) " >&6
11713 else
11714   case $WC in
11715   [\\/]* | ?:[\\/]*)
11716   ac_cv_path_WC="$WC" # Let the user override the test with a path.
11717   ;;
11718   *)
11719   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11720 for as_dir in $PATH
11721 do
11722   IFS=$as_save_IFS
11723   test -z "$as_dir" && as_dir=.
11724     for ac_exec_ext in '' $ac_executable_extensions; do
11725   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11726     ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
11727     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11728     break 2
11729   fi
11730 done
11731   done
11732 IFS=$as_save_IFS
11733 
11734   ;;
11735 esac
11736 fi
11737 WC=$ac_cv_path_WC
11738 if test -n "$WC"; then
11739   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
11740 $as_echo "$WC" >&6; }
11741 else
11742   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11743 $as_echo "no" >&6; }
11744 fi
11745 
11746 
11747   test -n "$WC" && break
11748 done
11749 
11750   else
11751     # The variable is set, but is it from the command line or the environment?
11752 
11753     # Try to remove the string !WC! from our list.
11754     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!WC!/}
11755     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11756       # If it failed, the variable was not from the command line. Ignore it,
11757       # but warn the user (except for BASH, which is always set by the calling BASH).
11758       if test "xWC" != xBASH; then
11759         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of WC from the environment. Use command line variables instead." >&5
11760 $as_echo "$as_me: WARNING: Ignoring value of WC from the environment. Use command line variables instead." >&2;}
11761       fi
11762       # Try to locate tool using the code snippet
11763       for ac_prog in wc
11764 do
11765   # Extract the first word of "$ac_prog", so it can be a program name with args.
11766 set dummy $ac_prog; ac_word=$2
11767 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11768 $as_echo_n "checking for $ac_word... " >&6; }
11769 if ${ac_cv_path_WC+:} false; then :
11770   $as_echo_n "(cached) " >&6
11771 else
11772   case $WC in
11773   [\\/]* | ?:[\\/]*)
11774   ac_cv_path_WC="$WC" # Let the user override the test with a path.
11775   ;;
11776   *)
11777   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11778 for as_dir in $PATH
11779 do
11780   IFS=$as_save_IFS
11781   test -z "$as_dir" && as_dir=.
11782     for ac_exec_ext in '' $ac_executable_extensions; do
11783   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11784     ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
11785     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11786     break 2
11787   fi
11788 done
11789   done
11790 IFS=$as_save_IFS
11791 
11792   ;;
11793 esac
11794 fi
11795 WC=$ac_cv_path_WC
11796 if test -n "$WC"; then
11797   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
11798 $as_echo "$WC" >&6; }
11799 else
11800   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11801 $as_echo "no" >&6; }
11802 fi
11803 
11804 
11805   test -n "$WC" && break
11806 done
11807 
11808     else
11809       # If it succeeded, then it was overridden by the user. We will use it
11810       # for the tool.
11811 
11812       # First remove it from the list of overridden variables, so we can test
11813       # for unknown variables in the end.
11814       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11815 
11816       # Check if we try to supply an empty value
11817       if test "x$WC" = x; then
11818         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool WC= (no value)" >&5
11819 $as_echo "$as_me: Setting user supplied tool WC= (no value)" >&6;}
11820         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WC" >&5
11821 $as_echo_n "checking for WC... " >&6; }
11822         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
11823 $as_echo "disabled" >&6; }
11824       else
11825         # Check if the provided tool contains a complete path.
11826         tool_specified="$WC"
11827         tool_basename="${tool_specified##*/}"
11828         if test "x$tool_basename" = "x$tool_specified"; then
11829           # A command without a complete path is provided, search $PATH.
11830           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool WC=$tool_basename" >&5
11831 $as_echo "$as_me: Will search for user supplied tool WC=$tool_basename" >&6;}
11832           # Extract the first word of "$tool_basename", so it can be a program name with args.
11833 set dummy $tool_basename; ac_word=$2
11834 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11835 $as_echo_n "checking for $ac_word... " >&6; }
11836 if ${ac_cv_path_WC+:} false; then :
11837   $as_echo_n "(cached) " >&6
11838 else
11839   case $WC in
11840   [\\/]* | ?:[\\/]*)
11841   ac_cv_path_WC="$WC" # Let the user override the test with a path.
11842   ;;
11843   *)
11844   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11845 for as_dir in $PATH
11846 do
11847   IFS=$as_save_IFS
11848   test -z "$as_dir" && as_dir=.
11849     for ac_exec_ext in '' $ac_executable_extensions; do
11850   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11851     ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
11852     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11853     break 2
11854   fi
11855 done
11856   done
11857 IFS=$as_save_IFS
11858 
11859   ;;
11860 esac
11861 fi
11862 WC=$ac_cv_path_WC
11863 if test -n "$WC"; then
11864   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
11865 $as_echo "$WC" >&6; }
11866 else
11867   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11868 $as_echo "no" >&6; }
11869 fi
11870 
11871 
11872           if test "x$WC" = x; then
11873             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11874           fi
11875         else
11876           # Otherwise we believe it is a complete path. Use it as it is.
11877           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool WC=$tool_specified" >&5
11878 $as_echo "$as_me: Will use user supplied tool WC=$tool_specified" >&6;}
11879           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WC" >&5
11880 $as_echo_n "checking for WC... " >&6; }
11881           if test ! -x "$tool_specified"; then
11882             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11883 $as_echo "not found" >&6; }
11884             as_fn_error $? "User supplied tool WC=$tool_specified does not exist or is not executable" "$LINENO" 5
11885           fi
11886           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11887 $as_echo "$tool_specified" >&6; }
11888         fi
11889       fi
11890     fi
11891 
11892   fi
11893 
11894 
11895 
11896   if test "x$WC" = x; then
11897     as_fn_error $? "Could not find required tool for WC" "$LINENO" 5
11898   fi
11899 
11900 
11901 
11902 
11903 
11904   # Publish this variable in the help.
11905 
11906 
11907   if [ -z "${WHICH+x}" ]; then
11908     # The variable is not set by user, try to locate tool using the code snippet
11909     for ac_prog in which
11910 do
11911   # Extract the first word of "$ac_prog", so it can be a program name with args.
11912 set dummy $ac_prog; ac_word=$2
11913 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11914 $as_echo_n "checking for $ac_word... " >&6; }
11915 if ${ac_cv_path_WHICH+:} false; then :
11916   $as_echo_n "(cached) " >&6
11917 else
11918   case $WHICH in
11919   [\\/]* | ?:[\\/]*)
11920   ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
11921   ;;
11922   *)
11923   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11924 for as_dir in $PATH
11925 do
11926   IFS=$as_save_IFS
11927   test -z "$as_dir" && as_dir=.
11928     for ac_exec_ext in '' $ac_executable_extensions; do
11929   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11930     ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
11931     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11932     break 2
11933   fi
11934 done
11935   done
11936 IFS=$as_save_IFS
11937 
11938   ;;
11939 esac
11940 fi
11941 WHICH=$ac_cv_path_WHICH
11942 if test -n "$WHICH"; then
11943   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
11944 $as_echo "$WHICH" >&6; }
11945 else
11946   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11947 $as_echo "no" >&6; }
11948 fi
11949 
11950 
11951   test -n "$WHICH" && break
11952 done
11953 
11954   else
11955     # The variable is set, but is it from the command line or the environment?
11956 
11957     # Try to remove the string !WHICH! from our list.
11958     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!WHICH!/}
11959     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11960       # If it failed, the variable was not from the command line. Ignore it,
11961       # but warn the user (except for BASH, which is always set by the calling BASH).
11962       if test "xWHICH" != xBASH; then
11963         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of WHICH from the environment. Use command line variables instead." >&5
11964 $as_echo "$as_me: WARNING: Ignoring value of WHICH from the environment. Use command line variables instead." >&2;}
11965       fi
11966       # Try to locate tool using the code snippet
11967       for ac_prog in which
11968 do
11969   # Extract the first word of "$ac_prog", so it can be a program name with args.
11970 set dummy $ac_prog; ac_word=$2
11971 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11972 $as_echo_n "checking for $ac_word... " >&6; }
11973 if ${ac_cv_path_WHICH+:} false; then :
11974   $as_echo_n "(cached) " >&6
11975 else
11976   case $WHICH in
11977   [\\/]* | ?:[\\/]*)
11978   ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
11979   ;;
11980   *)
11981   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11982 for as_dir in $PATH
11983 do
11984   IFS=$as_save_IFS
11985   test -z "$as_dir" && as_dir=.
11986     for ac_exec_ext in '' $ac_executable_extensions; do
11987   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11988     ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
11989     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11990     break 2
11991   fi
11992 done
11993   done
11994 IFS=$as_save_IFS
11995 
11996   ;;
11997 esac
11998 fi
11999 WHICH=$ac_cv_path_WHICH
12000 if test -n "$WHICH"; then
12001   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
12002 $as_echo "$WHICH" >&6; }
12003 else
12004   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12005 $as_echo "no" >&6; }
12006 fi
12007 
12008 
12009   test -n "$WHICH" && break
12010 done
12011 
12012     else
12013       # If it succeeded, then it was overridden by the user. We will use it
12014       # for the tool.
12015 
12016       # First remove it from the list of overridden variables, so we can test
12017       # for unknown variables in the end.
12018       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12019 
12020       # Check if we try to supply an empty value
12021       if test "x$WHICH" = x; then
12022         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool WHICH= (no value)" >&5
12023 $as_echo "$as_me: Setting user supplied tool WHICH= (no value)" >&6;}
12024         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WHICH" >&5
12025 $as_echo_n "checking for WHICH... " >&6; }
12026         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
12027 $as_echo "disabled" >&6; }
12028       else
12029         # Check if the provided tool contains a complete path.
12030         tool_specified="$WHICH"
12031         tool_basename="${tool_specified##*/}"
12032         if test "x$tool_basename" = "x$tool_specified"; then
12033           # A command without a complete path is provided, search $PATH.
12034           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool WHICH=$tool_basename" >&5
12035 $as_echo "$as_me: Will search for user supplied tool WHICH=$tool_basename" >&6;}
12036           # Extract the first word of "$tool_basename", so it can be a program name with args.
12037 set dummy $tool_basename; ac_word=$2
12038 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12039 $as_echo_n "checking for $ac_word... " >&6; }
12040 if ${ac_cv_path_WHICH+:} false; then :
12041   $as_echo_n "(cached) " >&6
12042 else
12043   case $WHICH in
12044   [\\/]* | ?:[\\/]*)
12045   ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
12046   ;;
12047   *)
12048   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12049 for as_dir in $PATH
12050 do
12051   IFS=$as_save_IFS
12052   test -z "$as_dir" && as_dir=.
12053     for ac_exec_ext in '' $ac_executable_extensions; do
12054   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12055     ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
12056     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12057     break 2
12058   fi
12059 done
12060   done
12061 IFS=$as_save_IFS
12062 
12063   ;;
12064 esac
12065 fi
12066 WHICH=$ac_cv_path_WHICH
12067 if test -n "$WHICH"; then
12068   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
12069 $as_echo "$WHICH" >&6; }
12070 else
12071   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12072 $as_echo "no" >&6; }
12073 fi
12074 
12075 
12076           if test "x$WHICH" = x; then
12077             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12078           fi
12079         else
12080           # Otherwise we believe it is a complete path. Use it as it is.
12081           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool WHICH=$tool_specified" >&5
12082 $as_echo "$as_me: Will use user supplied tool WHICH=$tool_specified" >&6;}
12083           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WHICH" >&5
12084 $as_echo_n "checking for WHICH... " >&6; }
12085           if test ! -x "$tool_specified"; then
12086             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12087 $as_echo "not found" >&6; }
12088             as_fn_error $? "User supplied tool WHICH=$tool_specified does not exist or is not executable" "$LINENO" 5
12089           fi
12090           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12091 $as_echo "$tool_specified" >&6; }
12092         fi
12093       fi
12094     fi
12095 
12096   fi
12097 
12098 
12099 
12100   if test "x$WHICH" = x; then
12101     as_fn_error $? "Could not find required tool for WHICH" "$LINENO" 5
12102   fi
12103 
12104 
12105 
12106 
12107 
12108   # Publish this variable in the help.
12109 
12110 
12111   if [ -z "${XARGS+x}" ]; then
12112     # The variable is not set by user, try to locate tool using the code snippet
12113     for ac_prog in xargs
12114 do
12115   # Extract the first word of "$ac_prog", so it can be a program name with args.
12116 set dummy $ac_prog; ac_word=$2
12117 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12118 $as_echo_n "checking for $ac_word... " >&6; }
12119 if ${ac_cv_path_XARGS+:} false; then :
12120   $as_echo_n "(cached) " >&6
12121 else
12122   case $XARGS in
12123   [\\/]* | ?:[\\/]*)
12124   ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
12125   ;;
12126   *)
12127   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12128 for as_dir in $PATH
12129 do
12130   IFS=$as_save_IFS
12131   test -z "$as_dir" && as_dir=.
12132     for ac_exec_ext in '' $ac_executable_extensions; do
12133   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12134     ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
12135     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12136     break 2
12137   fi
12138 done
12139   done
12140 IFS=$as_save_IFS
12141 
12142   ;;
12143 esac
12144 fi
12145 XARGS=$ac_cv_path_XARGS
12146 if test -n "$XARGS"; then
12147   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
12148 $as_echo "$XARGS" >&6; }
12149 else
12150   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12151 $as_echo "no" >&6; }
12152 fi
12153 
12154 
12155   test -n "$XARGS" && break
12156 done
12157 
12158   else
12159     # The variable is set, but is it from the command line or the environment?
12160 
12161     # Try to remove the string !XARGS! from our list.
12162     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!XARGS!/}
12163     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12164       # If it failed, the variable was not from the command line. Ignore it,
12165       # but warn the user (except for BASH, which is always set by the calling BASH).
12166       if test "xXARGS" != xBASH; then
12167         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of XARGS from the environment. Use command line variables instead." >&5
12168 $as_echo "$as_me: WARNING: Ignoring value of XARGS from the environment. Use command line variables instead." >&2;}
12169       fi
12170       # Try to locate tool using the code snippet
12171       for ac_prog in xargs
12172 do
12173   # Extract the first word of "$ac_prog", so it can be a program name with args.
12174 set dummy $ac_prog; ac_word=$2
12175 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12176 $as_echo_n "checking for $ac_word... " >&6; }
12177 if ${ac_cv_path_XARGS+:} false; then :
12178   $as_echo_n "(cached) " >&6
12179 else
12180   case $XARGS in
12181   [\\/]* | ?:[\\/]*)
12182   ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
12183   ;;
12184   *)
12185   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12186 for as_dir in $PATH
12187 do
12188   IFS=$as_save_IFS
12189   test -z "$as_dir" && as_dir=.
12190     for ac_exec_ext in '' $ac_executable_extensions; do
12191   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12192     ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
12193     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12194     break 2
12195   fi
12196 done
12197   done
12198 IFS=$as_save_IFS
12199 
12200   ;;
12201 esac
12202 fi
12203 XARGS=$ac_cv_path_XARGS
12204 if test -n "$XARGS"; then
12205   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
12206 $as_echo "$XARGS" >&6; }
12207 else
12208   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12209 $as_echo "no" >&6; }
12210 fi
12211 
12212 
12213   test -n "$XARGS" && break
12214 done
12215 
12216     else
12217       # If it succeeded, then it was overridden by the user. We will use it
12218       # for the tool.
12219 
12220       # First remove it from the list of overridden variables, so we can test
12221       # for unknown variables in the end.
12222       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12223 
12224       # Check if we try to supply an empty value
12225       if test "x$XARGS" = x; then
12226         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool XARGS= (no value)" >&5
12227 $as_echo "$as_me: Setting user supplied tool XARGS= (no value)" >&6;}
12228         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XARGS" >&5
12229 $as_echo_n "checking for XARGS... " >&6; }
12230         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
12231 $as_echo "disabled" >&6; }
12232       else
12233         # Check if the provided tool contains a complete path.
12234         tool_specified="$XARGS"
12235         tool_basename="${tool_specified##*/}"
12236         if test "x$tool_basename" = "x$tool_specified"; then
12237           # A command without a complete path is provided, search $PATH.
12238           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool XARGS=$tool_basename" >&5
12239 $as_echo "$as_me: Will search for user supplied tool XARGS=$tool_basename" >&6;}
12240           # Extract the first word of "$tool_basename", so it can be a program name with args.
12241 set dummy $tool_basename; ac_word=$2
12242 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12243 $as_echo_n "checking for $ac_word... " >&6; }
12244 if ${ac_cv_path_XARGS+:} false; then :
12245   $as_echo_n "(cached) " >&6
12246 else
12247   case $XARGS in
12248   [\\/]* | ?:[\\/]*)
12249   ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
12250   ;;
12251   *)
12252   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12253 for as_dir in $PATH
12254 do
12255   IFS=$as_save_IFS
12256   test -z "$as_dir" && as_dir=.
12257     for ac_exec_ext in '' $ac_executable_extensions; do
12258   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12259     ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
12260     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12261     break 2
12262   fi
12263 done
12264   done
12265 IFS=$as_save_IFS
12266 
12267   ;;
12268 esac
12269 fi
12270 XARGS=$ac_cv_path_XARGS
12271 if test -n "$XARGS"; then
12272   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
12273 $as_echo "$XARGS" >&6; }
12274 else
12275   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12276 $as_echo "no" >&6; }
12277 fi
12278 
12279 
12280           if test "x$XARGS" = x; then
12281             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12282           fi
12283         else
12284           # Otherwise we believe it is a complete path. Use it as it is.
12285           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool XARGS=$tool_specified" >&5
12286 $as_echo "$as_me: Will use user supplied tool XARGS=$tool_specified" >&6;}
12287           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XARGS" >&5
12288 $as_echo_n "checking for XARGS... " >&6; }
12289           if test ! -x "$tool_specified"; then
12290             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12291 $as_echo "not found" >&6; }
12292             as_fn_error $? "User supplied tool XARGS=$tool_specified does not exist or is not executable" "$LINENO" 5
12293           fi
12294           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12295 $as_echo "$tool_specified" >&6; }
12296         fi
12297       fi
12298     fi
12299 
12300   fi
12301 
12302 
12303 
12304   if test "x$XARGS" = x; then
12305     as_fn_error $? "Could not find required tool for XARGS" "$LINENO" 5
12306   fi
12307 
12308 
12309 
12310   # Then required tools that require some special treatment.
12311 
12312 
12313   # Publish this variable in the help.
12314 
12315 
12316   if [ -z "${AWK+x}" ]; then
12317     # The variable is not set by user, try to locate tool using the code snippet
12318     for ac_prog in gawk mawk nawk awk
12319 do
12320   # Extract the first word of "$ac_prog", so it can be a program name with args.
12321 set dummy $ac_prog; ac_word=$2
12322 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12323 $as_echo_n "checking for $ac_word... " >&6; }
12324 if ${ac_cv_prog_AWK+:} false; then :
12325   $as_echo_n "(cached) " >&6
12326 else
12327   if test -n "$AWK"; then
12328   ac_cv_prog_AWK="$AWK" # Let the user override the test.
12329 else
12330 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12331 for as_dir in $PATH
12332 do
12333   IFS=$as_save_IFS
12334   test -z "$as_dir" && as_dir=.
12335     for ac_exec_ext in '' $ac_executable_extensions; do
12336   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12337     ac_cv_prog_AWK="$ac_prog"
12338     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12339     break 2
12340   fi
12341 done
12342   done
12343 IFS=$as_save_IFS
12344 
12345 fi
12346 fi
12347 AWK=$ac_cv_prog_AWK
12348 if test -n "$AWK"; then
12349   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
12350 $as_echo "$AWK" >&6; }
12351 else
12352   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12353 $as_echo "no" >&6; }
12354 fi
12355 
12356 
12357   test -n "$AWK" && break
12358 done
12359 
12360   else
12361     # The variable is set, but is it from the command line or the environment?
12362 
12363     # Try to remove the string !AWK! from our list.
12364     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!AWK!/}
12365     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12366       # If it failed, the variable was not from the command line. Ignore it,
12367       # but warn the user (except for BASH, which is always set by the calling BASH).
12368       if test "xAWK" != xBASH; then
12369         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of AWK from the environment. Use command line variables instead." >&5
12370 $as_echo "$as_me: WARNING: Ignoring value of AWK from the environment. Use command line variables instead." >&2;}
12371       fi
12372       # Try to locate tool using the code snippet
12373       for ac_prog in gawk mawk nawk awk
12374 do
12375   # Extract the first word of "$ac_prog", so it can be a program name with args.
12376 set dummy $ac_prog; ac_word=$2
12377 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12378 $as_echo_n "checking for $ac_word... " >&6; }
12379 if ${ac_cv_prog_AWK+:} false; then :
12380   $as_echo_n "(cached) " >&6
12381 else
12382   if test -n "$AWK"; then
12383   ac_cv_prog_AWK="$AWK" # Let the user override the test.
12384 else
12385 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12386 for as_dir in $PATH
12387 do
12388   IFS=$as_save_IFS
12389   test -z "$as_dir" && as_dir=.
12390     for ac_exec_ext in '' $ac_executable_extensions; do
12391   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12392     ac_cv_prog_AWK="$ac_prog"
12393     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12394     break 2
12395   fi
12396 done
12397   done
12398 IFS=$as_save_IFS
12399 
12400 fi
12401 fi
12402 AWK=$ac_cv_prog_AWK
12403 if test -n "$AWK"; then
12404   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
12405 $as_echo "$AWK" >&6; }
12406 else
12407   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12408 $as_echo "no" >&6; }
12409 fi
12410 
12411 
12412   test -n "$AWK" && break
12413 done
12414 
12415     else
12416       # If it succeeded, then it was overridden by the user. We will use it
12417       # for the tool.
12418 
12419       # First remove it from the list of overridden variables, so we can test
12420       # for unknown variables in the end.
12421       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12422 
12423       # Check if we try to supply an empty value
12424       if test "x$AWK" = x; then
12425         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool AWK= (no value)" >&5
12426 $as_echo "$as_me: Setting user supplied tool AWK= (no value)" >&6;}
12427         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for AWK" >&5
12428 $as_echo_n "checking for AWK... " >&6; }
12429         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
12430 $as_echo "disabled" >&6; }
12431       else
12432         # Check if the provided tool contains a complete path.
12433         tool_specified="$AWK"
12434         tool_basename="${tool_specified##*/}"
12435         if test "x$tool_basename" = "x$tool_specified"; then
12436           # A command without a complete path is provided, search $PATH.
12437           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool AWK=$tool_basename" >&5
12438 $as_echo "$as_me: Will search for user supplied tool AWK=$tool_basename" >&6;}
12439           # Extract the first word of "$tool_basename", so it can be a program name with args.
12440 set dummy $tool_basename; ac_word=$2
12441 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12442 $as_echo_n "checking for $ac_word... " >&6; }
12443 if ${ac_cv_path_AWK+:} false; then :
12444   $as_echo_n "(cached) " >&6
12445 else
12446   case $AWK in
12447   [\\/]* | ?:[\\/]*)
12448   ac_cv_path_AWK="$AWK" # Let the user override the test with a path.
12449   ;;
12450   *)
12451   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12452 for as_dir in $PATH
12453 do
12454   IFS=$as_save_IFS
12455   test -z "$as_dir" && as_dir=.
12456     for ac_exec_ext in '' $ac_executable_extensions; do
12457   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12458     ac_cv_path_AWK="$as_dir/$ac_word$ac_exec_ext"
12459     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12460     break 2
12461   fi
12462 done
12463   done
12464 IFS=$as_save_IFS
12465 
12466   ;;
12467 esac
12468 fi
12469 AWK=$ac_cv_path_AWK
12470 if test -n "$AWK"; then
12471   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
12472 $as_echo "$AWK" >&6; }
12473 else
12474   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12475 $as_echo "no" >&6; }
12476 fi
12477 
12478 
12479           if test "x$AWK" = x; then
12480             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12481           fi
12482         else
12483           # Otherwise we believe it is a complete path. Use it as it is.
12484           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool AWK=$tool_specified" >&5
12485 $as_echo "$as_me: Will use user supplied tool AWK=$tool_specified" >&6;}
12486           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for AWK" >&5
12487 $as_echo_n "checking for AWK... " >&6; }
12488           if test ! -x "$tool_specified"; then
12489             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12490 $as_echo "not found" >&6; }
12491             as_fn_error $? "User supplied tool AWK=$tool_specified does not exist or is not executable" "$LINENO" 5
12492           fi
12493           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12494 $as_echo "$tool_specified" >&6; }
12495         fi
12496       fi
12497     fi
12498 
12499   fi
12500 
12501 
12502   if test "x$AWK" = x; then
12503     as_fn_error $? "Could not find required tool for AWK" "$LINENO" 5
12504   fi
12505 
12506 
12507 
12508 
12509   # Publish this variable in the help.
12510 
12511 
12512   if [ -z "${GREP+x}" ]; then
12513     # The variable is not set by user, try to locate tool using the code snippet
12514     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
12515 $as_echo_n "checking for grep that handles long lines and -e... " >&6; }
12516 if ${ac_cv_path_GREP+:} false; then :
12517   $as_echo_n "(cached) " >&6
12518 else
12519   if test -z "$GREP"; then
12520   ac_path_GREP_found=false
12521   # Loop through the user's path and test for each of PROGNAME-LIST
12522   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12523 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
12524 do
12525   IFS=$as_save_IFS
12526   test -z "$as_dir" && as_dir=.
12527     for ac_prog in grep ggrep; do
12528     for ac_exec_ext in '' $ac_executable_extensions; do
12529       ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
12530       as_fn_executable_p "$ac_path_GREP" || continue
12531 # Check for GNU ac_path_GREP and select it if it is found.
12532   # Check for GNU $ac_path_GREP
12533 case `"$ac_path_GREP" --version 2>&1` in
12534 *GNU*)
12535   ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
12536 *)
12537   ac_count=0
12538   $as_echo_n 0123456789 >"conftest.in"
12539   while :
12540   do
12541     cat "conftest.in" "conftest.in" >"conftest.tmp"
12542     mv "conftest.tmp" "conftest.in"
12543     cp "conftest.in" "conftest.nl"
12544     $as_echo 'GREP' >> "conftest.nl"
12545     "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
12546     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12547     as_fn_arith $ac_count + 1 && ac_count=$as_val
12548     if test $ac_count -gt ${ac_path_GREP_max-0}; then
12549       # Best one so far, save it but keep looking for a better one
12550       ac_cv_path_GREP="$ac_path_GREP"
12551       ac_path_GREP_max=$ac_count
12552     fi
12553     # 10*(2^10) chars as input seems more than enough
12554     test $ac_count -gt 10 && break
12555   done
12556   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12557 esac
12558 
12559       $ac_path_GREP_found && break 3
12560     done
12561   done
12562   done
12563 IFS=$as_save_IFS
12564   if test -z "$ac_cv_path_GREP"; then
12565     as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
12566   fi
12567 else
12568   ac_cv_path_GREP=$GREP
12569 fi
12570 
12571 fi
12572 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
12573 $as_echo "$ac_cv_path_GREP" >&6; }
12574  GREP="$ac_cv_path_GREP"
12575 
12576 
12577   else
12578     # The variable is set, but is it from the command line or the environment?
12579 
12580     # Try to remove the string !GREP! from our list.
12581     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!GREP!/}
12582     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12583       # If it failed, the variable was not from the command line. Ignore it,
12584       # but warn the user (except for BASH, which is always set by the calling BASH).
12585       if test "xGREP" != xBASH; then
12586         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of GREP from the environment. Use command line variables instead." >&5
12587 $as_echo "$as_me: WARNING: Ignoring value of GREP from the environment. Use command line variables instead." >&2;}
12588       fi
12589       # Try to locate tool using the code snippet
12590       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
12591 $as_echo_n "checking for grep that handles long lines and -e... " >&6; }
12592 if ${ac_cv_path_GREP+:} false; then :
12593   $as_echo_n "(cached) " >&6
12594 else
12595   if test -z "$GREP"; then
12596   ac_path_GREP_found=false
12597   # Loop through the user's path and test for each of PROGNAME-LIST
12598   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12599 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
12600 do
12601   IFS=$as_save_IFS
12602   test -z "$as_dir" && as_dir=.
12603     for ac_prog in grep ggrep; do
12604     for ac_exec_ext in '' $ac_executable_extensions; do
12605       ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
12606       as_fn_executable_p "$ac_path_GREP" || continue
12607 # Check for GNU ac_path_GREP and select it if it is found.
12608   # Check for GNU $ac_path_GREP
12609 case `"$ac_path_GREP" --version 2>&1` in
12610 *GNU*)
12611   ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
12612 *)
12613   ac_count=0
12614   $as_echo_n 0123456789 >"conftest.in"
12615   while :
12616   do
12617     cat "conftest.in" "conftest.in" >"conftest.tmp"
12618     mv "conftest.tmp" "conftest.in"
12619     cp "conftest.in" "conftest.nl"
12620     $as_echo 'GREP' >> "conftest.nl"
12621     "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
12622     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12623     as_fn_arith $ac_count + 1 && ac_count=$as_val
12624     if test $ac_count -gt ${ac_path_GREP_max-0}; then
12625       # Best one so far, save it but keep looking for a better one
12626       ac_cv_path_GREP="$ac_path_GREP"
12627       ac_path_GREP_max=$ac_count
12628     fi
12629     # 10*(2^10) chars as input seems more than enough
12630     test $ac_count -gt 10 && break
12631   done
12632   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12633 esac
12634 
12635       $ac_path_GREP_found && break 3
12636     done
12637   done
12638   done
12639 IFS=$as_save_IFS
12640   if test -z "$ac_cv_path_GREP"; then
12641     as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
12642   fi
12643 else
12644   ac_cv_path_GREP=$GREP
12645 fi
12646 
12647 fi
12648 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
12649 $as_echo "$ac_cv_path_GREP" >&6; }
12650  GREP="$ac_cv_path_GREP"
12651 
12652 
12653     else
12654       # If it succeeded, then it was overridden by the user. We will use it
12655       # for the tool.
12656 
12657       # First remove it from the list of overridden variables, so we can test
12658       # for unknown variables in the end.
12659       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12660 
12661       # Check if we try to supply an empty value
12662       if test "x$GREP" = x; then
12663         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool GREP= (no value)" >&5
12664 $as_echo "$as_me: Setting user supplied tool GREP= (no value)" >&6;}
12665         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GREP" >&5
12666 $as_echo_n "checking for GREP... " >&6; }
12667         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
12668 $as_echo "disabled" >&6; }
12669       else
12670         # Check if the provided tool contains a complete path.
12671         tool_specified="$GREP"
12672         tool_basename="${tool_specified##*/}"
12673         if test "x$tool_basename" = "x$tool_specified"; then
12674           # A command without a complete path is provided, search $PATH.
12675           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool GREP=$tool_basename" >&5
12676 $as_echo "$as_me: Will search for user supplied tool GREP=$tool_basename" >&6;}
12677           # Extract the first word of "$tool_basename", so it can be a program name with args.
12678 set dummy $tool_basename; ac_word=$2
12679 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12680 $as_echo_n "checking for $ac_word... " >&6; }
12681 if ${ac_cv_path_GREP+:} false; then :
12682   $as_echo_n "(cached) " >&6
12683 else
12684   case $GREP in
12685   [\\/]* | ?:[\\/]*)
12686   ac_cv_path_GREP="$GREP" # Let the user override the test with a path.
12687   ;;
12688   *)
12689   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12690 for as_dir in $PATH
12691 do
12692   IFS=$as_save_IFS
12693   test -z "$as_dir" && as_dir=.
12694     for ac_exec_ext in '' $ac_executable_extensions; do
12695   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12696     ac_cv_path_GREP="$as_dir/$ac_word$ac_exec_ext"
12697     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12698     break 2
12699   fi
12700 done
12701   done
12702 IFS=$as_save_IFS
12703 
12704   ;;
12705 esac
12706 fi
12707 GREP=$ac_cv_path_GREP
12708 if test -n "$GREP"; then
12709   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GREP" >&5
12710 $as_echo "$GREP" >&6; }
12711 else
12712   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12713 $as_echo "no" >&6; }
12714 fi
12715 
12716 
12717           if test "x$GREP" = x; then
12718             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12719           fi
12720         else
12721           # Otherwise we believe it is a complete path. Use it as it is.
12722           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool GREP=$tool_specified" >&5
12723 $as_echo "$as_me: Will use user supplied tool GREP=$tool_specified" >&6;}
12724           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GREP" >&5
12725 $as_echo_n "checking for GREP... " >&6; }
12726           if test ! -x "$tool_specified"; then
12727             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12728 $as_echo "not found" >&6; }
12729             as_fn_error $? "User supplied tool GREP=$tool_specified does not exist or is not executable" "$LINENO" 5
12730           fi
12731           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12732 $as_echo "$tool_specified" >&6; }
12733         fi
12734       fi
12735     fi
12736 
12737   fi
12738 
12739 
12740   if test "x$GREP" = x; then
12741     as_fn_error $? "Could not find required tool for GREP" "$LINENO" 5
12742   fi
12743 
12744 
12745 
12746 
12747   # Publish this variable in the help.
12748 
12749 
12750   if [ -z "${EGREP+x}" ]; then
12751     # The variable is not set by user, try to locate tool using the code snippet
12752     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
12753 $as_echo_n "checking for egrep... " >&6; }
12754 if ${ac_cv_path_EGREP+:} false; then :
12755   $as_echo_n "(cached) " >&6
12756 else
12757   if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
12758    then ac_cv_path_EGREP="$GREP -E"
12759    else
12760      if test -z "$EGREP"; then
12761   ac_path_EGREP_found=false
12762   # Loop through the user's path and test for each of PROGNAME-LIST
12763   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12764 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
12765 do
12766   IFS=$as_save_IFS
12767   test -z "$as_dir" && as_dir=.
12768     for ac_prog in egrep; do
12769     for ac_exec_ext in '' $ac_executable_extensions; do
12770       ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
12771       as_fn_executable_p "$ac_path_EGREP" || continue
12772 # Check for GNU ac_path_EGREP and select it if it is found.
12773   # Check for GNU $ac_path_EGREP
12774 case `"$ac_path_EGREP" --version 2>&1` in
12775 *GNU*)
12776   ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
12777 *)
12778   ac_count=0
12779   $as_echo_n 0123456789 >"conftest.in"
12780   while :
12781   do
12782     cat "conftest.in" "conftest.in" >"conftest.tmp"
12783     mv "conftest.tmp" "conftest.in"
12784     cp "conftest.in" "conftest.nl"
12785     $as_echo 'EGREP' >> "conftest.nl"
12786     "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
12787     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12788     as_fn_arith $ac_count + 1 && ac_count=$as_val
12789     if test $ac_count -gt ${ac_path_EGREP_max-0}; then
12790       # Best one so far, save it but keep looking for a better one
12791       ac_cv_path_EGREP="$ac_path_EGREP"
12792       ac_path_EGREP_max=$ac_count
12793     fi
12794     # 10*(2^10) chars as input seems more than enough
12795     test $ac_count -gt 10 && break
12796   done
12797   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12798 esac
12799 
12800       $ac_path_EGREP_found && break 3
12801     done
12802   done
12803   done
12804 IFS=$as_save_IFS
12805   if test -z "$ac_cv_path_EGREP"; then
12806     as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
12807   fi
12808 else
12809   ac_cv_path_EGREP=$EGREP
12810 fi
12811 
12812    fi
12813 fi
12814 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
12815 $as_echo "$ac_cv_path_EGREP" >&6; }
12816  EGREP="$ac_cv_path_EGREP"
12817 
12818 
12819   else
12820     # The variable is set, but is it from the command line or the environment?
12821 
12822     # Try to remove the string !EGREP! from our list.
12823     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!EGREP!/}
12824     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12825       # If it failed, the variable was not from the command line. Ignore it,
12826       # but warn the user (except for BASH, which is always set by the calling BASH).
12827       if test "xEGREP" != xBASH; then
12828         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of EGREP from the environment. Use command line variables instead." >&5
12829 $as_echo "$as_me: WARNING: Ignoring value of EGREP from the environment. Use command line variables instead." >&2;}
12830       fi
12831       # Try to locate tool using the code snippet
12832       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
12833 $as_echo_n "checking for egrep... " >&6; }
12834 if ${ac_cv_path_EGREP+:} false; then :
12835   $as_echo_n "(cached) " >&6
12836 else
12837   if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
12838    then ac_cv_path_EGREP="$GREP -E"
12839    else
12840      if test -z "$EGREP"; then
12841   ac_path_EGREP_found=false
12842   # Loop through the user's path and test for each of PROGNAME-LIST
12843   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12844 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
12845 do
12846   IFS=$as_save_IFS
12847   test -z "$as_dir" && as_dir=.
12848     for ac_prog in egrep; do
12849     for ac_exec_ext in '' $ac_executable_extensions; do
12850       ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
12851       as_fn_executable_p "$ac_path_EGREP" || continue
12852 # Check for GNU ac_path_EGREP and select it if it is found.
12853   # Check for GNU $ac_path_EGREP
12854 case `"$ac_path_EGREP" --version 2>&1` in
12855 *GNU*)
12856   ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
12857 *)
12858   ac_count=0
12859   $as_echo_n 0123456789 >"conftest.in"
12860   while :
12861   do
12862     cat "conftest.in" "conftest.in" >"conftest.tmp"
12863     mv "conftest.tmp" "conftest.in"
12864     cp "conftest.in" "conftest.nl"
12865     $as_echo 'EGREP' >> "conftest.nl"
12866     "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
12867     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12868     as_fn_arith $ac_count + 1 && ac_count=$as_val
12869     if test $ac_count -gt ${ac_path_EGREP_max-0}; then
12870       # Best one so far, save it but keep looking for a better one
12871       ac_cv_path_EGREP="$ac_path_EGREP"
12872       ac_path_EGREP_max=$ac_count
12873     fi
12874     # 10*(2^10) chars as input seems more than enough
12875     test $ac_count -gt 10 && break
12876   done
12877   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12878 esac
12879 
12880       $ac_path_EGREP_found && break 3
12881     done
12882   done
12883   done
12884 IFS=$as_save_IFS
12885   if test -z "$ac_cv_path_EGREP"; then
12886     as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
12887   fi
12888 else
12889   ac_cv_path_EGREP=$EGREP
12890 fi
12891 
12892    fi
12893 fi
12894 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
12895 $as_echo "$ac_cv_path_EGREP" >&6; }
12896  EGREP="$ac_cv_path_EGREP"
12897 
12898 
12899     else
12900       # If it succeeded, then it was overridden by the user. We will use it
12901       # for the tool.
12902 
12903       # First remove it from the list of overridden variables, so we can test
12904       # for unknown variables in the end.
12905       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12906 
12907       # Check if we try to supply an empty value
12908       if test "x$EGREP" = x; then
12909         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool EGREP= (no value)" >&5
12910 $as_echo "$as_me: Setting user supplied tool EGREP= (no value)" >&6;}
12911         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EGREP" >&5
12912 $as_echo_n "checking for EGREP... " >&6; }
12913         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
12914 $as_echo "disabled" >&6; }
12915       else
12916         # Check if the provided tool contains a complete path.
12917         tool_specified="$EGREP"
12918         tool_basename="${tool_specified##*/}"
12919         if test "x$tool_basename" = "x$tool_specified"; then
12920           # A command without a complete path is provided, search $PATH.
12921           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool EGREP=$tool_basename" >&5
12922 $as_echo "$as_me: Will search for user supplied tool EGREP=$tool_basename" >&6;}
12923           # Extract the first word of "$tool_basename", so it can be a program name with args.
12924 set dummy $tool_basename; ac_word=$2
12925 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12926 $as_echo_n "checking for $ac_word... " >&6; }
12927 if ${ac_cv_path_EGREP+:} false; then :
12928   $as_echo_n "(cached) " >&6
12929 else
12930   case $EGREP in
12931   [\\/]* | ?:[\\/]*)
12932   ac_cv_path_EGREP="$EGREP" # Let the user override the test with a path.
12933   ;;
12934   *)
12935   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12936 for as_dir in $PATH
12937 do
12938   IFS=$as_save_IFS
12939   test -z "$as_dir" && as_dir=.
12940     for ac_exec_ext in '' $ac_executable_extensions; do
12941   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12942     ac_cv_path_EGREP="$as_dir/$ac_word$ac_exec_ext"
12943     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12944     break 2
12945   fi
12946 done
12947   done
12948 IFS=$as_save_IFS
12949 
12950   ;;
12951 esac
12952 fi
12953 EGREP=$ac_cv_path_EGREP
12954 if test -n "$EGREP"; then
12955   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EGREP" >&5
12956 $as_echo "$EGREP" >&6; }
12957 else
12958   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12959 $as_echo "no" >&6; }
12960 fi
12961 
12962 
12963           if test "x$EGREP" = x; then
12964             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12965           fi
12966         else
12967           # Otherwise we believe it is a complete path. Use it as it is.
12968           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool EGREP=$tool_specified" >&5
12969 $as_echo "$as_me: Will use user supplied tool EGREP=$tool_specified" >&6;}
12970           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EGREP" >&5
12971 $as_echo_n "checking for EGREP... " >&6; }
12972           if test ! -x "$tool_specified"; then
12973             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12974 $as_echo "not found" >&6; }
12975             as_fn_error $? "User supplied tool EGREP=$tool_specified does not exist or is not executable" "$LINENO" 5
12976           fi
12977           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12978 $as_echo "$tool_specified" >&6; }
12979         fi
12980       fi
12981     fi
12982 
12983   fi
12984 
12985 
12986   if test "x$EGREP" = x; then
12987     as_fn_error $? "Could not find required tool for EGREP" "$LINENO" 5
12988   fi
12989 
12990 
12991 
12992 
12993   # Publish this variable in the help.
12994 
12995 
12996   if [ -z "${FGREP+x}" ]; then
12997     # The variable is not set by user, try to locate tool using the code snippet
12998     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
12999 $as_echo_n "checking for fgrep... " >&6; }
13000 if ${ac_cv_path_FGREP+:} false; then :
13001   $as_echo_n "(cached) " >&6
13002 else
13003   if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
13004    then ac_cv_path_FGREP="$GREP -F"
13005    else
13006      if test -z "$FGREP"; then
13007   ac_path_FGREP_found=false
13008   # Loop through the user's path and test for each of PROGNAME-LIST
13009   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13010 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
13011 do
13012   IFS=$as_save_IFS
13013   test -z "$as_dir" && as_dir=.
13014     for ac_prog in fgrep; do
13015     for ac_exec_ext in '' $ac_executable_extensions; do
13016       ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
13017       as_fn_executable_p "$ac_path_FGREP" || continue
13018 # Check for GNU ac_path_FGREP and select it if it is found.
13019   # Check for GNU $ac_path_FGREP
13020 case `"$ac_path_FGREP" --version 2>&1` in
13021 *GNU*)
13022   ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
13023 *)
13024   ac_count=0
13025   $as_echo_n 0123456789 >"conftest.in"
13026   while :
13027   do
13028     cat "conftest.in" "conftest.in" >"conftest.tmp"
13029     mv "conftest.tmp" "conftest.in"
13030     cp "conftest.in" "conftest.nl"
13031     $as_echo 'FGREP' >> "conftest.nl"
13032     "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
13033     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
13034     as_fn_arith $ac_count + 1 && ac_count=$as_val
13035     if test $ac_count -gt ${ac_path_FGREP_max-0}; then
13036       # Best one so far, save it but keep looking for a better one
13037       ac_cv_path_FGREP="$ac_path_FGREP"
13038       ac_path_FGREP_max=$ac_count
13039     fi
13040     # 10*(2^10) chars as input seems more than enough
13041     test $ac_count -gt 10 && break
13042   done
13043   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
13044 esac
13045 
13046       $ac_path_FGREP_found && break 3
13047     done
13048   done
13049   done
13050 IFS=$as_save_IFS
13051   if test -z "$ac_cv_path_FGREP"; then
13052     as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
13053   fi
13054 else
13055   ac_cv_path_FGREP=$FGREP
13056 fi
13057 
13058    fi
13059 fi
13060 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
13061 $as_echo "$ac_cv_path_FGREP" >&6; }
13062  FGREP="$ac_cv_path_FGREP"
13063 
13064 
13065   else
13066     # The variable is set, but is it from the command line or the environment?
13067 
13068     # Try to remove the string !FGREP! from our list.
13069     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FGREP!/}
13070     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
13071       # If it failed, the variable was not from the command line. Ignore it,
13072       # but warn the user (except for BASH, which is always set by the calling BASH).
13073       if test "xFGREP" != xBASH; then
13074         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FGREP from the environment. Use command line variables instead." >&5
13075 $as_echo "$as_me: WARNING: Ignoring value of FGREP from the environment. Use command line variables instead." >&2;}
13076       fi
13077       # Try to locate tool using the code snippet
13078       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
13079 $as_echo_n "checking for fgrep... " >&6; }
13080 if ${ac_cv_path_FGREP+:} false; then :
13081   $as_echo_n "(cached) " >&6
13082 else
13083   if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
13084    then ac_cv_path_FGREP="$GREP -F"
13085    else
13086      if test -z "$FGREP"; then
13087   ac_path_FGREP_found=false
13088   # Loop through the user's path and test for each of PROGNAME-LIST
13089   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13090 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
13091 do
13092   IFS=$as_save_IFS
13093   test -z "$as_dir" && as_dir=.
13094     for ac_prog in fgrep; do
13095     for ac_exec_ext in '' $ac_executable_extensions; do
13096       ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
13097       as_fn_executable_p "$ac_path_FGREP" || continue
13098 # Check for GNU ac_path_FGREP and select it if it is found.
13099   # Check for GNU $ac_path_FGREP
13100 case `"$ac_path_FGREP" --version 2>&1` in
13101 *GNU*)
13102   ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
13103 *)
13104   ac_count=0
13105   $as_echo_n 0123456789 >"conftest.in"
13106   while :
13107   do
13108     cat "conftest.in" "conftest.in" >"conftest.tmp"
13109     mv "conftest.tmp" "conftest.in"
13110     cp "conftest.in" "conftest.nl"
13111     $as_echo 'FGREP' >> "conftest.nl"
13112     "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
13113     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
13114     as_fn_arith $ac_count + 1 && ac_count=$as_val
13115     if test $ac_count -gt ${ac_path_FGREP_max-0}; then
13116       # Best one so far, save it but keep looking for a better one
13117       ac_cv_path_FGREP="$ac_path_FGREP"
13118       ac_path_FGREP_max=$ac_count
13119     fi
13120     # 10*(2^10) chars as input seems more than enough
13121     test $ac_count -gt 10 && break
13122   done
13123   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
13124 esac
13125 
13126       $ac_path_FGREP_found && break 3
13127     done
13128   done
13129   done
13130 IFS=$as_save_IFS
13131   if test -z "$ac_cv_path_FGREP"; then
13132     as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
13133   fi
13134 else
13135   ac_cv_path_FGREP=$FGREP
13136 fi
13137 
13138    fi
13139 fi
13140 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
13141 $as_echo "$ac_cv_path_FGREP" >&6; }
13142  FGREP="$ac_cv_path_FGREP"
13143 
13144 
13145     else
13146       # If it succeeded, then it was overridden by the user. We will use it
13147       # for the tool.
13148 
13149       # First remove it from the list of overridden variables, so we can test
13150       # for unknown variables in the end.
13151       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13152 
13153       # Check if we try to supply an empty value
13154       if test "x$FGREP" = x; then
13155         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool FGREP= (no value)" >&5
13156 $as_echo "$as_me: Setting user supplied tool FGREP= (no value)" >&6;}
13157         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FGREP" >&5
13158 $as_echo_n "checking for FGREP... " >&6; }
13159         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
13160 $as_echo "disabled" >&6; }
13161       else
13162         # Check if the provided tool contains a complete path.
13163         tool_specified="$FGREP"
13164         tool_basename="${tool_specified##*/}"
13165         if test "x$tool_basename" = "x$tool_specified"; then
13166           # A command without a complete path is provided, search $PATH.
13167           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FGREP=$tool_basename" >&5
13168 $as_echo "$as_me: Will search for user supplied tool FGREP=$tool_basename" >&6;}
13169           # Extract the first word of "$tool_basename", so it can be a program name with args.
13170 set dummy $tool_basename; ac_word=$2
13171 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13172 $as_echo_n "checking for $ac_word... " >&6; }
13173 if ${ac_cv_path_FGREP+:} false; then :
13174   $as_echo_n "(cached) " >&6
13175 else
13176   case $FGREP in
13177   [\\/]* | ?:[\\/]*)
13178   ac_cv_path_FGREP="$FGREP" # Let the user override the test with a path.
13179   ;;
13180   *)
13181   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13182 for as_dir in $PATH
13183 do
13184   IFS=$as_save_IFS
13185   test -z "$as_dir" && as_dir=.
13186     for ac_exec_ext in '' $ac_executable_extensions; do
13187   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13188     ac_cv_path_FGREP="$as_dir/$ac_word$ac_exec_ext"
13189     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13190     break 2
13191   fi
13192 done
13193   done
13194 IFS=$as_save_IFS
13195 
13196   ;;
13197 esac
13198 fi
13199 FGREP=$ac_cv_path_FGREP
13200 if test -n "$FGREP"; then
13201   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FGREP" >&5
13202 $as_echo "$FGREP" >&6; }
13203 else
13204   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13205 $as_echo "no" >&6; }
13206 fi
13207 
13208 
13209           if test "x$FGREP" = x; then
13210             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13211           fi
13212         else
13213           # Otherwise we believe it is a complete path. Use it as it is.
13214           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FGREP=$tool_specified" >&5
13215 $as_echo "$as_me: Will use user supplied tool FGREP=$tool_specified" >&6;}
13216           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FGREP" >&5
13217 $as_echo_n "checking for FGREP... " >&6; }
13218           if test ! -x "$tool_specified"; then
13219             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13220 $as_echo "not found" >&6; }
13221             as_fn_error $? "User supplied tool FGREP=$tool_specified does not exist or is not executable" "$LINENO" 5
13222           fi
13223           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13224 $as_echo "$tool_specified" >&6; }
13225         fi
13226       fi
13227     fi
13228 
13229   fi
13230 
13231 
13232   if test "x$FGREP" = x; then
13233     as_fn_error $? "Could not find required tool for FGREP" "$LINENO" 5
13234   fi
13235 
13236 
13237 
13238 
13239   # Publish this variable in the help.
13240 
13241 
13242   if [ -z "${SED+x}" ]; then
13243     # The variable is not set by user, try to locate tool using the code snippet
13244     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
13245 $as_echo_n "checking for a sed that does not truncate output... " >&6; }
13246 if ${ac_cv_path_SED+:} false; then :
13247   $as_echo_n "(cached) " >&6
13248 else
13249             ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
13250      for ac_i in 1 2 3 4 5 6 7; do
13251        ac_script="$ac_script$as_nl$ac_script"
13252      done
13253      echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
13254      { ac_script=; unset ac_script;}
13255      if test -z "$SED"; then
13256   ac_path_SED_found=false
13257   # Loop through the user's path and test for each of PROGNAME-LIST
13258   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13259 for as_dir in $PATH
13260 do
13261   IFS=$as_save_IFS
13262   test -z "$as_dir" && as_dir=.
13263     for ac_prog in sed gsed; do
13264     for ac_exec_ext in '' $ac_executable_extensions; do
13265       ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
13266       as_fn_executable_p "$ac_path_SED" || continue
13267 # Check for GNU ac_path_SED and select it if it is found.
13268   # Check for GNU $ac_path_SED
13269 case `"$ac_path_SED" --version 2>&1` in
13270 *GNU*)
13271   ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
13272 *)
13273   ac_count=0
13274   $as_echo_n 0123456789 >"conftest.in"
13275   while :
13276   do
13277     cat "conftest.in" "conftest.in" >"conftest.tmp"
13278     mv "conftest.tmp" "conftest.in"
13279     cp "conftest.in" "conftest.nl"
13280     $as_echo '' >> "conftest.nl"
13281     "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
13282     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
13283     as_fn_arith $ac_count + 1 && ac_count=$as_val
13284     if test $ac_count -gt ${ac_path_SED_max-0}; then
13285       # Best one so far, save it but keep looking for a better one
13286       ac_cv_path_SED="$ac_path_SED"
13287       ac_path_SED_max=$ac_count
13288     fi
13289     # 10*(2^10) chars as input seems more than enough
13290     test $ac_count -gt 10 && break
13291   done
13292   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
13293 esac
13294 
13295       $ac_path_SED_found && break 3
13296     done
13297   done
13298   done
13299 IFS=$as_save_IFS
13300   if test -z "$ac_cv_path_SED"; then
13301     as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
13302   fi
13303 else
13304   ac_cv_path_SED=$SED
13305 fi
13306 
13307 fi
13308 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
13309 $as_echo "$ac_cv_path_SED" >&6; }
13310  SED="$ac_cv_path_SED"
13311   rm -f conftest.sed
13312 
13313   else
13314     # The variable is set, but is it from the command line or the environment?
13315 
13316     # Try to remove the string !SED! from our list.
13317     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SED!/}
13318     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
13319       # If it failed, the variable was not from the command line. Ignore it,
13320       # but warn the user (except for BASH, which is always set by the calling BASH).
13321       if test "xSED" != xBASH; then
13322         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SED from the environment. Use command line variables instead." >&5
13323 $as_echo "$as_me: WARNING: Ignoring value of SED from the environment. Use command line variables instead." >&2;}
13324       fi
13325       # Try to locate tool using the code snippet
13326       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
13327 $as_echo_n "checking for a sed that does not truncate output... " >&6; }
13328 if ${ac_cv_path_SED+:} false; then :
13329   $as_echo_n "(cached) " >&6
13330 else
13331             ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
13332      for ac_i in 1 2 3 4 5 6 7; do
13333        ac_script="$ac_script$as_nl$ac_script"
13334      done
13335      echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
13336      { ac_script=; unset ac_script;}
13337      if test -z "$SED"; then
13338   ac_path_SED_found=false
13339   # Loop through the user's path and test for each of PROGNAME-LIST
13340   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13341 for as_dir in $PATH
13342 do
13343   IFS=$as_save_IFS
13344   test -z "$as_dir" && as_dir=.
13345     for ac_prog in sed gsed; do
13346     for ac_exec_ext in '' $ac_executable_extensions; do
13347       ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
13348       as_fn_executable_p "$ac_path_SED" || continue
13349 # Check for GNU ac_path_SED and select it if it is found.
13350   # Check for GNU $ac_path_SED
13351 case `"$ac_path_SED" --version 2>&1` in
13352 *GNU*)
13353   ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
13354 *)
13355   ac_count=0
13356   $as_echo_n 0123456789 >"conftest.in"
13357   while :
13358   do
13359     cat "conftest.in" "conftest.in" >"conftest.tmp"
13360     mv "conftest.tmp" "conftest.in"
13361     cp "conftest.in" "conftest.nl"
13362     $as_echo '' >> "conftest.nl"
13363     "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
13364     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
13365     as_fn_arith $ac_count + 1 && ac_count=$as_val
13366     if test $ac_count -gt ${ac_path_SED_max-0}; then
13367       # Best one so far, save it but keep looking for a better one
13368       ac_cv_path_SED="$ac_path_SED"
13369       ac_path_SED_max=$ac_count
13370     fi
13371     # 10*(2^10) chars as input seems more than enough
13372     test $ac_count -gt 10 && break
13373   done
13374   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
13375 esac
13376 
13377       $ac_path_SED_found && break 3
13378     done
13379   done
13380   done
13381 IFS=$as_save_IFS
13382   if test -z "$ac_cv_path_SED"; then
13383     as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
13384   fi
13385 else
13386   ac_cv_path_SED=$SED
13387 fi
13388 
13389 fi
13390 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
13391 $as_echo "$ac_cv_path_SED" >&6; }
13392  SED="$ac_cv_path_SED"
13393   rm -f conftest.sed
13394 
13395     else
13396       # If it succeeded, then it was overridden by the user. We will use it
13397       # for the tool.
13398 
13399       # First remove it from the list of overridden variables, so we can test
13400       # for unknown variables in the end.
13401       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13402 
13403       # Check if we try to supply an empty value
13404       if test "x$SED" = x; then
13405         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool SED= (no value)" >&5
13406 $as_echo "$as_me: Setting user supplied tool SED= (no value)" >&6;}
13407         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SED" >&5
13408 $as_echo_n "checking for SED... " >&6; }
13409         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
13410 $as_echo "disabled" >&6; }
13411       else
13412         # Check if the provided tool contains a complete path.
13413         tool_specified="$SED"
13414         tool_basename="${tool_specified##*/}"
13415         if test "x$tool_basename" = "x$tool_specified"; then
13416           # A command without a complete path is provided, search $PATH.
13417           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SED=$tool_basename" >&5
13418 $as_echo "$as_me: Will search for user supplied tool SED=$tool_basename" >&6;}
13419           # Extract the first word of "$tool_basename", so it can be a program name with args.
13420 set dummy $tool_basename; ac_word=$2
13421 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13422 $as_echo_n "checking for $ac_word... " >&6; }
13423 if ${ac_cv_path_SED+:} false; then :
13424   $as_echo_n "(cached) " >&6
13425 else
13426   case $SED in
13427   [\\/]* | ?:[\\/]*)
13428   ac_cv_path_SED="$SED" # Let the user override the test with a path.
13429   ;;
13430   *)
13431   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13432 for as_dir in $PATH
13433 do
13434   IFS=$as_save_IFS
13435   test -z "$as_dir" && as_dir=.
13436     for ac_exec_ext in '' $ac_executable_extensions; do
13437   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13438     ac_cv_path_SED="$as_dir/$ac_word$ac_exec_ext"
13439     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13440     break 2
13441   fi
13442 done
13443   done
13444 IFS=$as_save_IFS
13445 
13446   ;;
13447 esac
13448 fi
13449 SED=$ac_cv_path_SED
13450 if test -n "$SED"; then
13451   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SED" >&5
13452 $as_echo "$SED" >&6; }
13453 else
13454   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13455 $as_echo "no" >&6; }
13456 fi
13457 
13458 
13459           if test "x$SED" = x; then
13460             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13461           fi
13462         else
13463           # Otherwise we believe it is a complete path. Use it as it is.
13464           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SED=$tool_specified" >&5
13465 $as_echo "$as_me: Will use user supplied tool SED=$tool_specified" >&6;}
13466           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SED" >&5
13467 $as_echo_n "checking for SED... " >&6; }
13468           if test ! -x "$tool_specified"; then
13469             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13470 $as_echo "not found" >&6; }
13471             as_fn_error $? "User supplied tool SED=$tool_specified does not exist or is not executable" "$LINENO" 5
13472           fi
13473           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13474 $as_echo "$tool_specified" >&6; }
13475         fi
13476       fi
13477     fi
13478 
13479   fi
13480 
13481 
13482   if test "x$SED" = x; then
13483     as_fn_error $? "Could not find required tool for SED" "$LINENO" 5
13484   fi
13485 
13486 
13487 
13488   # Always force rm.
13489   RM="$RM -f"
13490 
13491   # pwd behaves differently on various platforms and some don't support the -L flag.
13492   # Always use the bash builtin pwd to get uniform behavior.
13493   THEPWDCMD=pwd
13494 
13495   # These are not required on all platforms
13496 
13497 
13498   # Publish this variable in the help.
13499 
13500 
13501   if [ -z "${CYGPATH+x}" ]; then
13502     # The variable is not set by user, try to locate tool using the code snippet
13503     for ac_prog in cygpath
13504 do
13505   # Extract the first word of "$ac_prog", so it can be a program name with args.
13506 set dummy $ac_prog; ac_word=$2
13507 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13508 $as_echo_n "checking for $ac_word... " >&6; }
13509 if ${ac_cv_path_CYGPATH+:} false; then :
13510   $as_echo_n "(cached) " >&6
13511 else
13512   case $CYGPATH in
13513   [\\/]* | ?:[\\/]*)
13514   ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
13515   ;;
13516   *)
13517   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13518 for as_dir in $PATH
13519 do
13520   IFS=$as_save_IFS
13521   test -z "$as_dir" && as_dir=.
13522     for ac_exec_ext in '' $ac_executable_extensions; do
13523   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13524     ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
13525     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13526     break 2
13527   fi
13528 done
13529   done
13530 IFS=$as_save_IFS
13531 
13532   ;;
13533 esac
13534 fi
13535 CYGPATH=$ac_cv_path_CYGPATH
13536 if test -n "$CYGPATH"; then
13537   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
13538 $as_echo "$CYGPATH" >&6; }
13539 else
13540   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13541 $as_echo "no" >&6; }
13542 fi
13543 
13544 
13545   test -n "$CYGPATH" && break
13546 done
13547 
13548   else
13549     # The variable is set, but is it from the command line or the environment?
13550 
13551     # Try to remove the string !CYGPATH! from our list.
13552     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CYGPATH!/}
13553     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
13554       # If it failed, the variable was not from the command line. Ignore it,
13555       # but warn the user (except for BASH, which is always set by the calling BASH).
13556       if test "xCYGPATH" != xBASH; then
13557         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CYGPATH from the environment. Use command line variables instead." >&5
13558 $as_echo "$as_me: WARNING: Ignoring value of CYGPATH from the environment. Use command line variables instead." >&2;}
13559       fi
13560       # Try to locate tool using the code snippet
13561       for ac_prog in cygpath
13562 do
13563   # Extract the first word of "$ac_prog", so it can be a program name with args.
13564 set dummy $ac_prog; ac_word=$2
13565 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13566 $as_echo_n "checking for $ac_word... " >&6; }
13567 if ${ac_cv_path_CYGPATH+:} false; then :
13568   $as_echo_n "(cached) " >&6
13569 else
13570   case $CYGPATH in
13571   [\\/]* | ?:[\\/]*)
13572   ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
13573   ;;
13574   *)
13575   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13576 for as_dir in $PATH
13577 do
13578   IFS=$as_save_IFS
13579   test -z "$as_dir" && as_dir=.
13580     for ac_exec_ext in '' $ac_executable_extensions; do
13581   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13582     ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
13583     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13584     break 2
13585   fi
13586 done
13587   done
13588 IFS=$as_save_IFS
13589 
13590   ;;
13591 esac
13592 fi
13593 CYGPATH=$ac_cv_path_CYGPATH
13594 if test -n "$CYGPATH"; then
13595   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
13596 $as_echo "$CYGPATH" >&6; }
13597 else
13598   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13599 $as_echo "no" >&6; }
13600 fi
13601 
13602 
13603   test -n "$CYGPATH" && break
13604 done
13605 
13606     else
13607       # If it succeeded, then it was overridden by the user. We will use it
13608       # for the tool.
13609 
13610       # First remove it from the list of overridden variables, so we can test
13611       # for unknown variables in the end.
13612       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13613 
13614       # Check if we try to supply an empty value
13615       if test "x$CYGPATH" = x; then
13616         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CYGPATH= (no value)" >&5
13617 $as_echo "$as_me: Setting user supplied tool CYGPATH= (no value)" >&6;}
13618         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CYGPATH" >&5
13619 $as_echo_n "checking for CYGPATH... " >&6; }
13620         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
13621 $as_echo "disabled" >&6; }
13622       else
13623         # Check if the provided tool contains a complete path.
13624         tool_specified="$CYGPATH"
13625         tool_basename="${tool_specified##*/}"
13626         if test "x$tool_basename" = "x$tool_specified"; then
13627           # A command without a complete path is provided, search $PATH.
13628           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CYGPATH=$tool_basename" >&5
13629 $as_echo "$as_me: Will search for user supplied tool CYGPATH=$tool_basename" >&6;}
13630           # Extract the first word of "$tool_basename", so it can be a program name with args.
13631 set dummy $tool_basename; ac_word=$2
13632 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13633 $as_echo_n "checking for $ac_word... " >&6; }
13634 if ${ac_cv_path_CYGPATH+:} false; then :
13635   $as_echo_n "(cached) " >&6
13636 else
13637   case $CYGPATH in
13638   [\\/]* | ?:[\\/]*)
13639   ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
13640   ;;
13641   *)
13642   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13643 for as_dir in $PATH
13644 do
13645   IFS=$as_save_IFS
13646   test -z "$as_dir" && as_dir=.
13647     for ac_exec_ext in '' $ac_executable_extensions; do
13648   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13649     ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
13650     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13651     break 2
13652   fi
13653 done
13654   done
13655 IFS=$as_save_IFS
13656 
13657   ;;
13658 esac
13659 fi
13660 CYGPATH=$ac_cv_path_CYGPATH
13661 if test -n "$CYGPATH"; then
13662   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
13663 $as_echo "$CYGPATH" >&6; }
13664 else
13665   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13666 $as_echo "no" >&6; }
13667 fi
13668 
13669 
13670           if test "x$CYGPATH" = x; then
13671             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13672           fi
13673         else
13674           # Otherwise we believe it is a complete path. Use it as it is.
13675           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CYGPATH=$tool_specified" >&5
13676 $as_echo "$as_me: Will use user supplied tool CYGPATH=$tool_specified" >&6;}
13677           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CYGPATH" >&5
13678 $as_echo_n "checking for CYGPATH... " >&6; }
13679           if test ! -x "$tool_specified"; then
13680             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13681 $as_echo "not found" >&6; }
13682             as_fn_error $? "User supplied tool CYGPATH=$tool_specified does not exist or is not executable" "$LINENO" 5
13683           fi
13684           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13685 $as_echo "$tool_specified" >&6; }
13686         fi
13687       fi
13688     fi
13689 
13690   fi
13691 
13692 
13693 
13694 
13695   # Publish this variable in the help.
13696 
13697 
13698   if [ -z "${READLINK+x}" ]; then
13699     # The variable is not set by user, try to locate tool using the code snippet
13700     for ac_prog in greadlink readlink
13701 do
13702   # Extract the first word of "$ac_prog", so it can be a program name with args.
13703 set dummy $ac_prog; ac_word=$2
13704 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13705 $as_echo_n "checking for $ac_word... " >&6; }
13706 if ${ac_cv_path_READLINK+:} false; then :
13707   $as_echo_n "(cached) " >&6
13708 else
13709   case $READLINK in
13710   [\\/]* | ?:[\\/]*)
13711   ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
13712   ;;
13713   *)
13714   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13715 for as_dir in $PATH
13716 do
13717   IFS=$as_save_IFS
13718   test -z "$as_dir" && as_dir=.
13719     for ac_exec_ext in '' $ac_executable_extensions; do
13720   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13721     ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
13722     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13723     break 2
13724   fi
13725 done
13726   done
13727 IFS=$as_save_IFS
13728 
13729   ;;
13730 esac
13731 fi
13732 READLINK=$ac_cv_path_READLINK
13733 if test -n "$READLINK"; then
13734   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
13735 $as_echo "$READLINK" >&6; }
13736 else
13737   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13738 $as_echo "no" >&6; }
13739 fi
13740 
13741 
13742   test -n "$READLINK" && break
13743 done
13744 
13745   else
13746     # The variable is set, but is it from the command line or the environment?
13747 
13748     # Try to remove the string !READLINK! from our list.
13749     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!READLINK!/}
13750     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
13751       # If it failed, the variable was not from the command line. Ignore it,
13752       # but warn the user (except for BASH, which is always set by the calling BASH).
13753       if test "xREADLINK" != xBASH; then
13754         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of READLINK from the environment. Use command line variables instead." >&5
13755 $as_echo "$as_me: WARNING: Ignoring value of READLINK from the environment. Use command line variables instead." >&2;}
13756       fi
13757       # Try to locate tool using the code snippet
13758       for ac_prog in greadlink readlink
13759 do
13760   # Extract the first word of "$ac_prog", so it can be a program name with args.
13761 set dummy $ac_prog; ac_word=$2
13762 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13763 $as_echo_n "checking for $ac_word... " >&6; }
13764 if ${ac_cv_path_READLINK+:} false; then :
13765   $as_echo_n "(cached) " >&6
13766 else
13767   case $READLINK in
13768   [\\/]* | ?:[\\/]*)
13769   ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
13770   ;;
13771   *)
13772   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13773 for as_dir in $PATH
13774 do
13775   IFS=$as_save_IFS
13776   test -z "$as_dir" && as_dir=.
13777     for ac_exec_ext in '' $ac_executable_extensions; do
13778   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13779     ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
13780     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13781     break 2
13782   fi
13783 done
13784   done
13785 IFS=$as_save_IFS
13786 
13787   ;;
13788 esac
13789 fi
13790 READLINK=$ac_cv_path_READLINK
13791 if test -n "$READLINK"; then
13792   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
13793 $as_echo "$READLINK" >&6; }
13794 else
13795   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13796 $as_echo "no" >&6; }
13797 fi
13798 
13799 
13800   test -n "$READLINK" && break
13801 done
13802 
13803     else
13804       # If it succeeded, then it was overridden by the user. We will use it
13805       # for the tool.
13806 
13807       # First remove it from the list of overridden variables, so we can test
13808       # for unknown variables in the end.
13809       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13810 
13811       # Check if we try to supply an empty value
13812       if test "x$READLINK" = x; then
13813         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool READLINK= (no value)" >&5
13814 $as_echo "$as_me: Setting user supplied tool READLINK= (no value)" >&6;}
13815         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READLINK" >&5
13816 $as_echo_n "checking for READLINK... " >&6; }
13817         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
13818 $as_echo "disabled" >&6; }
13819       else
13820         # Check if the provided tool contains a complete path.
13821         tool_specified="$READLINK"
13822         tool_basename="${tool_specified##*/}"
13823         if test "x$tool_basename" = "x$tool_specified"; then
13824           # A command without a complete path is provided, search $PATH.
13825           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool READLINK=$tool_basename" >&5
13826 $as_echo "$as_me: Will search for user supplied tool READLINK=$tool_basename" >&6;}
13827           # Extract the first word of "$tool_basename", so it can be a program name with args.
13828 set dummy $tool_basename; ac_word=$2
13829 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13830 $as_echo_n "checking for $ac_word... " >&6; }
13831 if ${ac_cv_path_READLINK+:} false; then :
13832   $as_echo_n "(cached) " >&6
13833 else
13834   case $READLINK in
13835   [\\/]* | ?:[\\/]*)
13836   ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
13837   ;;
13838   *)
13839   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13840 for as_dir in $PATH
13841 do
13842   IFS=$as_save_IFS
13843   test -z "$as_dir" && as_dir=.
13844     for ac_exec_ext in '' $ac_executable_extensions; do
13845   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13846     ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
13847     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13848     break 2
13849   fi
13850 done
13851   done
13852 IFS=$as_save_IFS
13853 
13854   ;;
13855 esac
13856 fi
13857 READLINK=$ac_cv_path_READLINK
13858 if test -n "$READLINK"; then
13859   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
13860 $as_echo "$READLINK" >&6; }
13861 else
13862   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13863 $as_echo "no" >&6; }
13864 fi
13865 
13866 
13867           if test "x$READLINK" = x; then
13868             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13869           fi
13870         else
13871           # Otherwise we believe it is a complete path. Use it as it is.
13872           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool READLINK=$tool_specified" >&5
13873 $as_echo "$as_me: Will use user supplied tool READLINK=$tool_specified" >&6;}
13874           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READLINK" >&5
13875 $as_echo_n "checking for READLINK... " >&6; }
13876           if test ! -x "$tool_specified"; then
13877             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13878 $as_echo "not found" >&6; }
13879             as_fn_error $? "User supplied tool READLINK=$tool_specified does not exist or is not executable" "$LINENO" 5
13880           fi
13881           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13882 $as_echo "$tool_specified" >&6; }
13883         fi
13884       fi
13885     fi
13886 
13887   fi
13888 
13889 
13890 
13891 
13892   # Publish this variable in the help.
13893 
13894 
13895   if [ -z "${DF+x}" ]; then
13896     # The variable is not set by user, try to locate tool using the code snippet
13897     for ac_prog in df
13898 do
13899   # Extract the first word of "$ac_prog", so it can be a program name with args.
13900 set dummy $ac_prog; ac_word=$2
13901 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13902 $as_echo_n "checking for $ac_word... " >&6; }
13903 if ${ac_cv_path_DF+:} false; then :
13904   $as_echo_n "(cached) " >&6
13905 else
13906   case $DF in
13907   [\\/]* | ?:[\\/]*)
13908   ac_cv_path_DF="$DF" # Let the user override the test with a path.
13909   ;;
13910   *)
13911   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13912 for as_dir in $PATH
13913 do
13914   IFS=$as_save_IFS
13915   test -z "$as_dir" && as_dir=.
13916     for ac_exec_ext in '' $ac_executable_extensions; do
13917   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13918     ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
13919     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13920     break 2
13921   fi
13922 done
13923   done
13924 IFS=$as_save_IFS
13925 
13926   ;;
13927 esac
13928 fi
13929 DF=$ac_cv_path_DF
13930 if test -n "$DF"; then
13931   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
13932 $as_echo "$DF" >&6; }
13933 else
13934   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13935 $as_echo "no" >&6; }
13936 fi
13937 
13938 
13939   test -n "$DF" && break
13940 done
13941 
13942   else
13943     # The variable is set, but is it from the command line or the environment?
13944 
13945     # Try to remove the string !DF! from our list.
13946     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DF!/}
13947     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
13948       # If it failed, the variable was not from the command line. Ignore it,
13949       # but warn the user (except for BASH, which is always set by the calling BASH).
13950       if test "xDF" != xBASH; then
13951         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DF from the environment. Use command line variables instead." >&5
13952 $as_echo "$as_me: WARNING: Ignoring value of DF from the environment. Use command line variables instead." >&2;}
13953       fi
13954       # Try to locate tool using the code snippet
13955       for ac_prog in df
13956 do
13957   # Extract the first word of "$ac_prog", so it can be a program name with args.
13958 set dummy $ac_prog; ac_word=$2
13959 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13960 $as_echo_n "checking for $ac_word... " >&6; }
13961 if ${ac_cv_path_DF+:} false; then :
13962   $as_echo_n "(cached) " >&6
13963 else
13964   case $DF in
13965   [\\/]* | ?:[\\/]*)
13966   ac_cv_path_DF="$DF" # Let the user override the test with a path.
13967   ;;
13968   *)
13969   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13970 for as_dir in $PATH
13971 do
13972   IFS=$as_save_IFS
13973   test -z "$as_dir" && as_dir=.
13974     for ac_exec_ext in '' $ac_executable_extensions; do
13975   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13976     ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
13977     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13978     break 2
13979   fi
13980 done
13981   done
13982 IFS=$as_save_IFS
13983 
13984   ;;
13985 esac
13986 fi
13987 DF=$ac_cv_path_DF
13988 if test -n "$DF"; then
13989   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
13990 $as_echo "$DF" >&6; }
13991 else
13992   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13993 $as_echo "no" >&6; }
13994 fi
13995 
13996 
13997   test -n "$DF" && break
13998 done
13999 
14000     else
14001       # If it succeeded, then it was overridden by the user. We will use it
14002       # for the tool.
14003 
14004       # First remove it from the list of overridden variables, so we can test
14005       # for unknown variables in the end.
14006       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
14007 
14008       # Check if we try to supply an empty value
14009       if test "x$DF" = x; then
14010         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool DF= (no value)" >&5
14011 $as_echo "$as_me: Setting user supplied tool DF= (no value)" >&6;}
14012         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DF" >&5
14013 $as_echo_n "checking for DF... " >&6; }
14014         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
14015 $as_echo "disabled" >&6; }
14016       else
14017         # Check if the provided tool contains a complete path.
14018         tool_specified="$DF"
14019         tool_basename="${tool_specified##*/}"
14020         if test "x$tool_basename" = "x$tool_specified"; then
14021           # A command without a complete path is provided, search $PATH.
14022           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DF=$tool_basename" >&5
14023 $as_echo "$as_me: Will search for user supplied tool DF=$tool_basename" >&6;}
14024           # Extract the first word of "$tool_basename", so it can be a program name with args.
14025 set dummy $tool_basename; ac_word=$2
14026 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14027 $as_echo_n "checking for $ac_word... " >&6; }
14028 if ${ac_cv_path_DF+:} false; then :
14029   $as_echo_n "(cached) " >&6
14030 else
14031   case $DF in
14032   [\\/]* | ?:[\\/]*)
14033   ac_cv_path_DF="$DF" # Let the user override the test with a path.
14034   ;;
14035   *)
14036   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14037 for as_dir in $PATH
14038 do
14039   IFS=$as_save_IFS
14040   test -z "$as_dir" && as_dir=.
14041     for ac_exec_ext in '' $ac_executable_extensions; do
14042   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14043     ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
14044     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14045     break 2
14046   fi
14047 done
14048   done
14049 IFS=$as_save_IFS
14050 
14051   ;;
14052 esac
14053 fi
14054 DF=$ac_cv_path_DF
14055 if test -n "$DF"; then
14056   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
14057 $as_echo "$DF" >&6; }
14058 else
14059   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14060 $as_echo "no" >&6; }
14061 fi
14062 
14063 
14064           if test "x$DF" = x; then
14065             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
14066           fi
14067         else
14068           # Otherwise we believe it is a complete path. Use it as it is.
14069           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DF=$tool_specified" >&5
14070 $as_echo "$as_me: Will use user supplied tool DF=$tool_specified" >&6;}
14071           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DF" >&5
14072 $as_echo_n "checking for DF... " >&6; }
14073           if test ! -x "$tool_specified"; then
14074             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
14075 $as_echo "not found" >&6; }
14076             as_fn_error $? "User supplied tool DF=$tool_specified does not exist or is not executable" "$LINENO" 5
14077           fi
14078           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
14079 $as_echo "$tool_specified" >&6; }
14080         fi
14081       fi
14082     fi
14083 
14084   fi
14085 
14086 
14087 
14088 
14089   # Publish this variable in the help.
14090 
14091 
14092   if [ -z "${CPIO+x}" ]; then
14093     # The variable is not set by user, try to locate tool using the code snippet
14094     for ac_prog in cpio bsdcpio
14095 do
14096   # Extract the first word of "$ac_prog", so it can be a program name with args.
14097 set dummy $ac_prog; ac_word=$2
14098 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14099 $as_echo_n "checking for $ac_word... " >&6; }
14100 if ${ac_cv_path_CPIO+:} false; then :
14101   $as_echo_n "(cached) " >&6
14102 else
14103   case $CPIO in
14104   [\\/]* | ?:[\\/]*)
14105   ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
14106   ;;
14107   *)
14108   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14109 for as_dir in $PATH
14110 do
14111   IFS=$as_save_IFS
14112   test -z "$as_dir" && as_dir=.
14113     for ac_exec_ext in '' $ac_executable_extensions; do
14114   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14115     ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
14116     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14117     break 2
14118   fi
14119 done
14120   done
14121 IFS=$as_save_IFS
14122 
14123   ;;
14124 esac
14125 fi
14126 CPIO=$ac_cv_path_CPIO
14127 if test -n "$CPIO"; then
14128   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
14129 $as_echo "$CPIO" >&6; }
14130 else
14131   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14132 $as_echo "no" >&6; }
14133 fi
14134 
14135 
14136   test -n "$CPIO" && break
14137 done
14138 
14139   else
14140     # The variable is set, but is it from the command line or the environment?
14141 
14142     # Try to remove the string !CPIO! from our list.
14143     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CPIO!/}
14144     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
14145       # If it failed, the variable was not from the command line. Ignore it,
14146       # but warn the user (except for BASH, which is always set by the calling BASH).
14147       if test "xCPIO" != xBASH; then
14148         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CPIO from the environment. Use command line variables instead." >&5
14149 $as_echo "$as_me: WARNING: Ignoring value of CPIO from the environment. Use command line variables instead." >&2;}
14150       fi
14151       # Try to locate tool using the code snippet
14152       for ac_prog in cpio bsdcpio
14153 do
14154   # Extract the first word of "$ac_prog", so it can be a program name with args.
14155 set dummy $ac_prog; ac_word=$2
14156 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14157 $as_echo_n "checking for $ac_word... " >&6; }
14158 if ${ac_cv_path_CPIO+:} false; then :
14159   $as_echo_n "(cached) " >&6
14160 else
14161   case $CPIO in
14162   [\\/]* | ?:[\\/]*)
14163   ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
14164   ;;
14165   *)
14166   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14167 for as_dir in $PATH
14168 do
14169   IFS=$as_save_IFS
14170   test -z "$as_dir" && as_dir=.
14171     for ac_exec_ext in '' $ac_executable_extensions; do
14172   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14173     ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
14174     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14175     break 2
14176   fi
14177 done
14178   done
14179 IFS=$as_save_IFS
14180 
14181   ;;
14182 esac
14183 fi
14184 CPIO=$ac_cv_path_CPIO
14185 if test -n "$CPIO"; then
14186   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
14187 $as_echo "$CPIO" >&6; }
14188 else
14189   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14190 $as_echo "no" >&6; }
14191 fi
14192 
14193 
14194   test -n "$CPIO" && break
14195 done
14196 
14197     else
14198       # If it succeeded, then it was overridden by the user. We will use it
14199       # for the tool.
14200 
14201       # First remove it from the list of overridden variables, so we can test
14202       # for unknown variables in the end.
14203       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
14204 
14205       # Check if we try to supply an empty value
14206       if test "x$CPIO" = x; then
14207         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CPIO= (no value)" >&5
14208 $as_echo "$as_me: Setting user supplied tool CPIO= (no value)" >&6;}
14209         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CPIO" >&5
14210 $as_echo_n "checking for CPIO... " >&6; }
14211         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
14212 $as_echo "disabled" >&6; }
14213       else
14214         # Check if the provided tool contains a complete path.
14215         tool_specified="$CPIO"
14216         tool_basename="${tool_specified##*/}"
14217         if test "x$tool_basename" = "x$tool_specified"; then
14218           # A command without a complete path is provided, search $PATH.
14219           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CPIO=$tool_basename" >&5
14220 $as_echo "$as_me: Will search for user supplied tool CPIO=$tool_basename" >&6;}
14221           # Extract the first word of "$tool_basename", so it can be a program name with args.
14222 set dummy $tool_basename; ac_word=$2
14223 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14224 $as_echo_n "checking for $ac_word... " >&6; }
14225 if ${ac_cv_path_CPIO+:} false; then :
14226   $as_echo_n "(cached) " >&6
14227 else
14228   case $CPIO in
14229   [\\/]* | ?:[\\/]*)
14230   ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
14231   ;;
14232   *)
14233   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14234 for as_dir in $PATH
14235 do
14236   IFS=$as_save_IFS
14237   test -z "$as_dir" && as_dir=.
14238     for ac_exec_ext in '' $ac_executable_extensions; do
14239   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14240     ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
14241     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14242     break 2
14243   fi
14244 done
14245   done
14246 IFS=$as_save_IFS
14247 
14248   ;;
14249 esac
14250 fi
14251 CPIO=$ac_cv_path_CPIO
14252 if test -n "$CPIO"; then
14253   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
14254 $as_echo "$CPIO" >&6; }
14255 else
14256   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14257 $as_echo "no" >&6; }
14258 fi
14259 
14260 
14261           if test "x$CPIO" = x; then
14262             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
14263           fi
14264         else
14265           # Otherwise we believe it is a complete path. Use it as it is.
14266           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CPIO=$tool_specified" >&5
14267 $as_echo "$as_me: Will use user supplied tool CPIO=$tool_specified" >&6;}
14268           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CPIO" >&5
14269 $as_echo_n "checking for CPIO... " >&6; }
14270           if test ! -x "$tool_specified"; then
14271             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
14272 $as_echo "not found" >&6; }
14273             as_fn_error $? "User supplied tool CPIO=$tool_specified does not exist or is not executable" "$LINENO" 5
14274           fi
14275           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
14276 $as_echo "$tool_specified" >&6; }
14277         fi
14278       fi
14279     fi
14280 
14281   fi
14282 
14283 
14284 
14285 
14286   # Publish this variable in the help.
14287 
14288 
14289   if [ -z "${NICE+x}" ]; then
14290     # The variable is not set by user, try to locate tool using the code snippet
14291     for ac_prog in nice
14292 do
14293   # Extract the first word of "$ac_prog", so it can be a program name with args.
14294 set dummy $ac_prog; ac_word=$2
14295 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14296 $as_echo_n "checking for $ac_word... " >&6; }
14297 if ${ac_cv_path_NICE+:} false; then :
14298   $as_echo_n "(cached) " >&6
14299 else
14300   case $NICE in
14301   [\\/]* | ?:[\\/]*)
14302   ac_cv_path_NICE="$NICE" # Let the user override the test with a path.
14303   ;;
14304   *)
14305   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14306 for as_dir in $PATH
14307 do
14308   IFS=$as_save_IFS
14309   test -z "$as_dir" && as_dir=.
14310     for ac_exec_ext in '' $ac_executable_extensions; do
14311   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14312     ac_cv_path_NICE="$as_dir/$ac_word$ac_exec_ext"
14313     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14314     break 2
14315   fi
14316 done
14317   done
14318 IFS=$as_save_IFS
14319 
14320   ;;
14321 esac
14322 fi
14323 NICE=$ac_cv_path_NICE
14324 if test -n "$NICE"; then
14325   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NICE" >&5
14326 $as_echo "$NICE" >&6; }
14327 else
14328   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14329 $as_echo "no" >&6; }
14330 fi
14331 
14332 
14333   test -n "$NICE" && break
14334 done
14335 
14336   else
14337     # The variable is set, but is it from the command line or the environment?
14338 
14339     # Try to remove the string !NICE! from our list.
14340     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!NICE!/}
14341     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
14342       # If it failed, the variable was not from the command line. Ignore it,
14343       # but warn the user (except for BASH, which is always set by the calling BASH).
14344       if test "xNICE" != xBASH; then
14345         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of NICE from the environment. Use command line variables instead." >&5
14346 $as_echo "$as_me: WARNING: Ignoring value of NICE from the environment. Use command line variables instead." >&2;}
14347       fi
14348       # Try to locate tool using the code snippet
14349       for ac_prog in nice
14350 do
14351   # Extract the first word of "$ac_prog", so it can be a program name with args.
14352 set dummy $ac_prog; ac_word=$2
14353 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14354 $as_echo_n "checking for $ac_word... " >&6; }
14355 if ${ac_cv_path_NICE+:} false; then :
14356   $as_echo_n "(cached) " >&6
14357 else
14358   case $NICE in
14359   [\\/]* | ?:[\\/]*)
14360   ac_cv_path_NICE="$NICE" # Let the user override the test with a path.
14361   ;;
14362   *)
14363   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14364 for as_dir in $PATH
14365 do
14366   IFS=$as_save_IFS
14367   test -z "$as_dir" && as_dir=.
14368     for ac_exec_ext in '' $ac_executable_extensions; do
14369   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14370     ac_cv_path_NICE="$as_dir/$ac_word$ac_exec_ext"
14371     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14372     break 2
14373   fi
14374 done
14375   done
14376 IFS=$as_save_IFS
14377 
14378   ;;
14379 esac
14380 fi
14381 NICE=$ac_cv_path_NICE
14382 if test -n "$NICE"; then
14383   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NICE" >&5
14384 $as_echo "$NICE" >&6; }
14385 else
14386   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14387 $as_echo "no" >&6; }
14388 fi
14389 
14390 
14391   test -n "$NICE" && break
14392 done
14393 
14394     else
14395       # If it succeeded, then it was overridden by the user. We will use it
14396       # for the tool.
14397 
14398       # First remove it from the list of overridden variables, so we can test
14399       # for unknown variables in the end.
14400       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
14401 
14402       # Check if we try to supply an empty value
14403       if test "x$NICE" = x; then
14404         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool NICE= (no value)" >&5
14405 $as_echo "$as_me: Setting user supplied tool NICE= (no value)" >&6;}
14406         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NICE" >&5
14407 $as_echo_n "checking for NICE... " >&6; }
14408         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
14409 $as_echo "disabled" >&6; }
14410       else
14411         # Check if the provided tool contains a complete path.
14412         tool_specified="$NICE"
14413         tool_basename="${tool_specified##*/}"
14414         if test "x$tool_basename" = "x$tool_specified"; then
14415           # A command without a complete path is provided, search $PATH.
14416           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool NICE=$tool_basename" >&5
14417 $as_echo "$as_me: Will search for user supplied tool NICE=$tool_basename" >&6;}
14418           # Extract the first word of "$tool_basename", so it can be a program name with args.
14419 set dummy $tool_basename; ac_word=$2
14420 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14421 $as_echo_n "checking for $ac_word... " >&6; }
14422 if ${ac_cv_path_NICE+:} false; then :
14423   $as_echo_n "(cached) " >&6
14424 else
14425   case $NICE in
14426   [\\/]* | ?:[\\/]*)
14427   ac_cv_path_NICE="$NICE" # Let the user override the test with a path.
14428   ;;
14429   *)
14430   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14431 for as_dir in $PATH
14432 do
14433   IFS=$as_save_IFS
14434   test -z "$as_dir" && as_dir=.
14435     for ac_exec_ext in '' $ac_executable_extensions; do
14436   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14437     ac_cv_path_NICE="$as_dir/$ac_word$ac_exec_ext"
14438     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14439     break 2
14440   fi
14441 done
14442   done
14443 IFS=$as_save_IFS
14444 
14445   ;;
14446 esac
14447 fi
14448 NICE=$ac_cv_path_NICE
14449 if test -n "$NICE"; then
14450   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NICE" >&5
14451 $as_echo "$NICE" >&6; }
14452 else
14453   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14454 $as_echo "no" >&6; }
14455 fi
14456 
14457 
14458           if test "x$NICE" = x; then
14459             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
14460           fi
14461         else
14462           # Otherwise we believe it is a complete path. Use it as it is.
14463           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool NICE=$tool_specified" >&5
14464 $as_echo "$as_me: Will use user supplied tool NICE=$tool_specified" >&6;}
14465           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NICE" >&5
14466 $as_echo_n "checking for NICE... " >&6; }
14467           if test ! -x "$tool_specified"; then
14468             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
14469 $as_echo "not found" >&6; }
14470             as_fn_error $? "User supplied tool NICE=$tool_specified does not exist or is not executable" "$LINENO" 5
14471           fi
14472           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
14473 $as_echo "$tool_specified" >&6; }
14474         fi
14475       fi
14476     fi
14477 
14478   fi
14479 
14480 
14481 
14482 
14483 # Now we can determine OpenJDK build and target platforms. This is required to
14484 # have early on.
14485 # Make sure we can run config.sub.
14486 $SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
14487   as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5
14488 
14489 { $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
14490 $as_echo_n "checking build system type... " >&6; }
14491 if ${ac_cv_build+:} false; then :
14492   $as_echo_n "(cached) " >&6
14493 else
14494   ac_build_alias=$build_alias
14495 test "x$ac_build_alias" = x &&
14496   ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
14497 test "x$ac_build_alias" = x &&
14498   as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5
14499 ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
14500   as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5
14501 
14502 fi
14503 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
14504 $as_echo "$ac_cv_build" >&6; }
14505 case $ac_cv_build in
14506 *-*-*) ;;
14507 *) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;;
14508 esac
14509 build=$ac_cv_build
14510 ac_save_IFS=$IFS; IFS='-'
14511 set x $ac_cv_build
14512 shift
14513 build_cpu=$1
14514 build_vendor=$2
14515 shift; shift
14516 # Remember, the first character of IFS is used to create $*,
14517 # except with old shells:
14518 build_os=$*
14519 IFS=$ac_save_IFS
14520 case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
14521 
14522 
14523 { $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
14524 $as_echo_n "checking host system type... " >&6; }
14525 if ${ac_cv_host+:} false; then :
14526   $as_echo_n "(cached) " >&6
14527 else
14528   if test "x$host_alias" = x; then
14529   ac_cv_host=$ac_cv_build
14530 else
14531   ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
14532     as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5
14533 fi
14534 
14535 fi
14536 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
14537 $as_echo "$ac_cv_host" >&6; }
14538 case $ac_cv_host in
14539 *-*-*) ;;
14540 *) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;;
14541 esac
14542 host=$ac_cv_host
14543 ac_save_IFS=$IFS; IFS='-'
14544 set x $ac_cv_host
14545 shift
14546 host_cpu=$1
14547 host_vendor=$2
14548 shift; shift
14549 # Remember, the first character of IFS is used to create $*,
14550 # except with old shells:
14551 host_os=$*
14552 IFS=$ac_save_IFS
14553 case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
14554 
14555 
14556 { $as_echo "$as_me:${as_lineno-$LINENO}: checking target system type" >&5
14557 $as_echo_n "checking target system type... " >&6; }
14558 if ${ac_cv_target+:} false; then :
14559   $as_echo_n "(cached) " >&6
14560 else
14561   if test "x$target_alias" = x; then
14562   ac_cv_target=$ac_cv_host
14563 else
14564   ac_cv_target=`$SHELL "$ac_aux_dir/config.sub" $target_alias` ||
14565     as_fn_error $? "$SHELL $ac_aux_dir/config.sub $target_alias failed" "$LINENO" 5
14566 fi
14567 
14568 fi
14569 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_target" >&5
14570 $as_echo "$ac_cv_target" >&6; }
14571 case $ac_cv_target in
14572 *-*-*) ;;
14573 *) as_fn_error $? "invalid value of canonical target" "$LINENO" 5;;
14574 esac
14575 target=$ac_cv_target
14576 ac_save_IFS=$IFS; IFS='-'
14577 set x $ac_cv_target
14578 shift
14579 target_cpu=$1
14580 target_vendor=$2
14581 shift; shift
14582 # Remember, the first character of IFS is used to create $*,
14583 # except with old shells:
14584 target_os=$*
14585 IFS=$ac_save_IFS
14586 case $target_os in *\ *) target_os=`echo "$target_os" | sed 's/ /-/g'`;; esac
14587 
14588 
14589 # The aliases save the names the user supplied, while $host etc.
14590 # will get canonicalized.
14591 test -n "$target_alias" &&
14592   test "$program_prefix$program_suffix$program_transform_name" = \
14593     NONENONEs,x,x, &&
14594   program_prefix=${target_alias}-
14595 
14596   # Figure out the build and target systems. # Note that in autoconf terminology, "build" is obvious, but "target"
14597   # is confusing; it assumes you are cross-compiling a cross-compiler (!)  and "target" is thus the target of the
14598   # product you're building. The target of this build is called "host". Since this is confusing to most people, we
14599   # have not adopted that system, but use "target" as the platform we are building for. In some places though we need
14600   # to use the configure naming style.
14601 
14602 
14603 
14604 
14605 
14606   # Copy the autoconf trip/quadruplet verbatim to OPENJDK_TARGET_AUTOCONF_NAME
14607   # (from the autoconf "host") and OPENJDK_BUILD_AUTOCONF_NAME
14608   # Note that we might later on rewrite e.g. OPENJDK_TARGET_CPU due to reduced build,
14609   # but this will not change the value of OPENJDK_TARGET_AUTOCONF_NAME.
14610   OPENJDK_TARGET_AUTOCONF_NAME="$host"
14611   OPENJDK_BUILD_AUTOCONF_NAME="$build"
14612 
14613 
14614 
14615   # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
14616 
14617   case "$build_os" in
14618     *linux*)
14619       VAR_OS=linux
14620       VAR_OS_TYPE=unix
14621       ;;
14622     *solaris*)
14623       VAR_OS=solaris
14624       VAR_OS_TYPE=unix
14625       ;;
14626     *darwin*)
14627       VAR_OS=macosx
14628       VAR_OS_TYPE=unix
14629       ;;
14630     *bsd*)
14631       VAR_OS=bsd
14632       VAR_OS_TYPE=unix
14633       ;;
14634     *cygwin*)
14635       VAR_OS=windows
14636       VAR_OS_ENV=windows.cygwin
14637       ;;
14638     *mingw*)
14639       VAR_OS=windows
14640       VAR_OS_ENV=windows.msys
14641       ;;
14642     *aix*)
14643       VAR_OS=aix
14644       VAR_OS_TYPE=unix
14645       ;;
14646     *)
14647       as_fn_error $? "unsupported operating system $build_os" "$LINENO" 5
14648       ;;
14649   esac
14650 
14651 
14652   # First argument is the cpu name from the trip/quad
14653   case "$build_cpu" in
14654     x86_64)
14655       VAR_CPU=x86_64
14656       VAR_CPU_ARCH=x86
14657       VAR_CPU_BITS=64
14658       VAR_CPU_ENDIAN=little
14659       ;;
14660     i?86)
14661       VAR_CPU=x86
14662       VAR_CPU_ARCH=x86
14663       VAR_CPU_BITS=32
14664       VAR_CPU_ENDIAN=little
14665       ;;
14666     arm*)
14667       VAR_CPU=arm
14668       VAR_CPU_ARCH=arm
14669       VAR_CPU_BITS=32
14670       VAR_CPU_ENDIAN=little
14671       ;;
14672     aarch64)
14673       VAR_CPU=aarch64
14674       VAR_CPU_ARCH=aarch64
14675       VAR_CPU_BITS=64
14676       VAR_CPU_ENDIAN=little
14677       ;;
14678     powerpc)
14679       VAR_CPU=ppc
14680       VAR_CPU_ARCH=ppc
14681       VAR_CPU_BITS=32
14682       VAR_CPU_ENDIAN=big
14683       ;;
14684     powerpc64)
14685       VAR_CPU=ppc64
14686       VAR_CPU_ARCH=ppc
14687       VAR_CPU_BITS=64
14688       VAR_CPU_ENDIAN=big
14689       ;;
14690     powerpc64le)
14691       VAR_CPU=ppc64
14692       VAR_CPU_ARCH=ppc
14693       VAR_CPU_BITS=64
14694       VAR_CPU_ENDIAN=little
14695       ;;
14696     s390)
14697       VAR_CPU=s390
14698       VAR_CPU_ARCH=s390
14699       VAR_CPU_BITS=32
14700       VAR_CPU_ENDIAN=big
14701       ;;
14702     s390x)
14703       VAR_CPU=s390x
14704       VAR_CPU_ARCH=s390
14705       VAR_CPU_BITS=64
14706       VAR_CPU_ENDIAN=big
14707       ;;
14708     sparc)
14709       VAR_CPU=sparc
14710       VAR_CPU_ARCH=sparc
14711       VAR_CPU_BITS=32
14712       VAR_CPU_ENDIAN=big
14713       ;;
14714     sparcv9|sparc64)
14715       VAR_CPU=sparcv9
14716       VAR_CPU_ARCH=sparc
14717       VAR_CPU_BITS=64
14718       VAR_CPU_ENDIAN=big
14719       ;;
14720     *)
14721       as_fn_error $? "unsupported cpu $build_cpu" "$LINENO" 5
14722       ;;
14723   esac
14724 
14725   # ..and setup our own variables. (Do this explicitely to facilitate searching)
14726   OPENJDK_BUILD_OS="$VAR_OS"
14727   if test "x$VAR_OS_TYPE" != x; then
14728     OPENJDK_BUILD_OS_TYPE="$VAR_OS_TYPE"
14729   else
14730     OPENJDK_BUILD_OS_TYPE="$VAR_OS"
14731   fi
14732   if test "x$VAR_OS_ENV" != x; then
14733     OPENJDK_BUILD_OS_ENV="$VAR_OS_ENV"
14734   else
14735     OPENJDK_BUILD_OS_ENV="$VAR_OS"
14736   fi
14737   OPENJDK_BUILD_CPU="$VAR_CPU"
14738   OPENJDK_BUILD_CPU_ARCH="$VAR_CPU_ARCH"
14739   OPENJDK_BUILD_CPU_BITS="$VAR_CPU_BITS"
14740   OPENJDK_BUILD_CPU_ENDIAN="$VAR_CPU_ENDIAN"
14741 
14742 
14743 
14744 
14745 
14746 
14747 
14748 
14749   { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-build os-cpu" >&5
14750 $as_echo_n "checking openjdk-build os-cpu... " >&6; }
14751   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&5
14752 $as_echo "$OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&6; }
14753 
14754   # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
14755 
14756   case "$host_os" in
14757     *linux*)
14758       VAR_OS=linux
14759       VAR_OS_TYPE=unix
14760       ;;
14761     *solaris*)
14762       VAR_OS=solaris
14763       VAR_OS_TYPE=unix
14764       ;;
14765     *darwin*)
14766       VAR_OS=macosx
14767       VAR_OS_TYPE=unix
14768       ;;
14769     *bsd*)
14770       VAR_OS=bsd
14771       VAR_OS_TYPE=unix
14772       ;;
14773     *cygwin*)
14774       VAR_OS=windows
14775       VAR_OS_ENV=windows.cygwin
14776       ;;
14777     *mingw*)
14778       VAR_OS=windows
14779       VAR_OS_ENV=windows.msys
14780       ;;
14781     *aix*)
14782       VAR_OS=aix
14783       VAR_OS_TYPE=unix
14784       ;;
14785     *)
14786       as_fn_error $? "unsupported operating system $host_os" "$LINENO" 5
14787       ;;
14788   esac
14789 
14790 
14791   # First argument is the cpu name from the trip/quad
14792   case "$host_cpu" in
14793     x86_64)
14794       VAR_CPU=x86_64
14795       VAR_CPU_ARCH=x86
14796       VAR_CPU_BITS=64
14797       VAR_CPU_ENDIAN=little
14798       ;;
14799     i?86)
14800       VAR_CPU=x86
14801       VAR_CPU_ARCH=x86
14802       VAR_CPU_BITS=32
14803       VAR_CPU_ENDIAN=little
14804       ;;
14805     arm*)
14806       VAR_CPU=arm
14807       VAR_CPU_ARCH=arm
14808       VAR_CPU_BITS=32
14809       VAR_CPU_ENDIAN=little
14810       ;;
14811     aarch64)
14812       VAR_CPU=aarch64
14813       VAR_CPU_ARCH=aarch64
14814       VAR_CPU_BITS=64
14815       VAR_CPU_ENDIAN=little
14816       ;;
14817     powerpc)
14818       VAR_CPU=ppc
14819       VAR_CPU_ARCH=ppc
14820       VAR_CPU_BITS=32
14821       VAR_CPU_ENDIAN=big
14822       ;;
14823     powerpc64)
14824       VAR_CPU=ppc64
14825       VAR_CPU_ARCH=ppc
14826       VAR_CPU_BITS=64
14827       VAR_CPU_ENDIAN=big
14828       ;;
14829     powerpc64le)
14830       VAR_CPU=ppc64
14831       VAR_CPU_ARCH=ppc
14832       VAR_CPU_BITS=64
14833       VAR_CPU_ENDIAN=little
14834       ;;
14835     s390)
14836       VAR_CPU=s390
14837       VAR_CPU_ARCH=s390
14838       VAR_CPU_BITS=32
14839       VAR_CPU_ENDIAN=big
14840       ;;
14841     s390x)
14842       VAR_CPU=s390x
14843       VAR_CPU_ARCH=s390
14844       VAR_CPU_BITS=64
14845       VAR_CPU_ENDIAN=big
14846       ;;
14847     sparc)
14848       VAR_CPU=sparc
14849       VAR_CPU_ARCH=sparc
14850       VAR_CPU_BITS=32
14851       VAR_CPU_ENDIAN=big
14852       ;;
14853     sparcv9|sparc64)
14854       VAR_CPU=sparcv9
14855       VAR_CPU_ARCH=sparc
14856       VAR_CPU_BITS=64
14857       VAR_CPU_ENDIAN=big
14858       ;;
14859     *)
14860       as_fn_error $? "unsupported cpu $host_cpu" "$LINENO" 5
14861       ;;
14862   esac
14863 
14864   # ... and setup our own variables. (Do this explicitely to facilitate searching)
14865   OPENJDK_TARGET_OS="$VAR_OS"
14866   if test "x$VAR_OS_TYPE" != x; then
14867     OPENJDK_TARGET_OS_TYPE="$VAR_OS_TYPE"
14868   else
14869     OPENJDK_TARGET_OS_TYPE="$VAR_OS"
14870   fi
14871   if test "x$VAR_OS_ENV" != x; then
14872     OPENJDK_TARGET_OS_ENV="$VAR_OS_ENV"
14873   else
14874     OPENJDK_TARGET_OS_ENV="$VAR_OS"
14875   fi
14876   OPENJDK_TARGET_CPU="$VAR_CPU"
14877   OPENJDK_TARGET_CPU_ARCH="$VAR_CPU_ARCH"
14878   OPENJDK_TARGET_CPU_BITS="$VAR_CPU_BITS"
14879   OPENJDK_TARGET_CPU_ENDIAN="$VAR_CPU_ENDIAN"
14880 
14881 
14882 
14883 
14884 
14885 
14886 
14887 
14888   { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-target os-cpu" >&5
14889 $as_echo_n "checking openjdk-target os-cpu... " >&6; }
14890   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&5
14891 $as_echo "$OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&6; }
14892 
14893 
14894 
14895 # Check whether --with-target-bits was given.
14896 if test "${with_target_bits+set}" = set; then :
14897   withval=$with_target_bits;
14898 fi
14899 
14900 
14901   # We have three types of compiles:
14902   # native  == normal compilation, target system == build system
14903   # cross   == traditional cross compilation, target system != build system; special toolchain needed
14904   # reduced == using native compilers, but with special flags (e.g. -m32) to produce 32-bit builds on 64-bit machines
14905   #
14906   if test "x$OPENJDK_BUILD_AUTOCONF_NAME" != "x$OPENJDK_TARGET_AUTOCONF_NAME"; then
14907     # We're doing a proper cross-compilation
14908     COMPILE_TYPE="cross"
14909   else
14910     COMPILE_TYPE="native"
14911   fi
14912 
14913   if test "x$with_target_bits" != x; then
14914     if test "x$COMPILE_TYPE" = "xcross"; then
14915       as_fn_error $? "It is not possible to combine --with-target-bits=X and proper cross-compilation. Choose either." "$LINENO" 5
14916     fi
14917 
14918     if test "x$with_target_bits" = x32 && test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
14919       # A reduced build is requested
14920       COMPILE_TYPE="reduced"
14921       OPENJDK_TARGET_CPU_BITS=32
14922       if test "x$OPENJDK_TARGET_CPU_ARCH" = "xx86"; then
14923         OPENJDK_TARGET_CPU=x86
14924       elif test "x$OPENJDK_TARGET_CPU_ARCH" = "xsparc"; then
14925         OPENJDK_TARGET_CPU=sparc
14926       else
14927         as_fn_error $? "Reduced build (--with-target-bits=32) is only supported on x86_64 and sparcv9" "$LINENO" 5
14928       fi
14929     elif test "x$with_target_bits" = x64 && test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
14930       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
14931     elif test "x$with_target_bits" = "x$OPENJDK_TARGET_CPU_BITS"; then
14932       { $as_echo "$as_me:${as_lineno-$LINENO}: --with-target-bits are set to build platform address size; argument has no meaning" >&5
14933 $as_echo "$as_me: --with-target-bits are set to build platform address size; argument has no meaning" >&6;}
14934     else
14935       as_fn_error $? "--with-target-bits can only be 32 or 64, you specified $with_target_bits!" "$LINENO" 5
14936     fi
14937   fi
14938 
14939 
14940   { $as_echo "$as_me:${as_lineno-$LINENO}: checking compilation type" >&5
14941 $as_echo_n "checking compilation type... " >&6; }
14942   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMPILE_TYPE" >&5
14943 $as_echo "$COMPILE_TYPE" >&6; }
14944 
14945 
14946   if test "x$OPENJDK_TARGET_OS" = "xsolaris"; then
14947     REQUIRED_OS_NAME=SunOS
14948     REQUIRED_OS_VERSION=5.10
14949   fi
14950   if test "x$OPENJDK_TARGET_OS" = "xlinux"; then
14951     REQUIRED_OS_NAME=Linux
14952     REQUIRED_OS_VERSION=2.6
14953   fi
14954   if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
14955     REQUIRED_OS_NAME=Windows
14956     if test "x$OPENJDK_TARGET_CPU_BITS" = "x64"; then
14957       REQUIRED_OS_VERSION=5.2
14958     else
14959       REQUIRED_OS_VERSION=5.1
14960     fi
14961   fi
14962   if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
14963     REQUIRED_OS_NAME=Darwin
14964     REQUIRED_OS_VERSION=11.2
14965   fi
14966 
14967 
14968 
14969 
14970 
14971   # Also store the legacy naming of the cpu.
14972   # Ie i586 and amd64 instead of x86 and x86_64
14973   OPENJDK_TARGET_CPU_LEGACY="$OPENJDK_TARGET_CPU"
14974   if test "x$OPENJDK_TARGET_CPU" = xx86; then
14975     OPENJDK_TARGET_CPU_LEGACY="i586"
14976   elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
14977     # On all platforms except MacOSX replace x86_64 with amd64.
14978     OPENJDK_TARGET_CPU_LEGACY="amd64"
14979   fi
14980 
14981 
14982   # And the second legacy naming of the cpu.
14983   # Ie i386 and amd64 instead of x86 and x86_64.
14984   OPENJDK_TARGET_CPU_LEGACY_LIB="$OPENJDK_TARGET_CPU"
14985   if test "x$OPENJDK_TARGET_CPU" = xx86; then
14986     OPENJDK_TARGET_CPU_LEGACY_LIB="i386"
14987   elif test "x$OPENJDK_TARGET_CPU" = xx86_64; then
14988     OPENJDK_TARGET_CPU_LEGACY_LIB="amd64"
14989   fi
14990 
14991 
14992   # This is the name of the cpu (but using i386 and amd64 instead of
14993   # x86 and x86_64, respectively), preceeded by a /, to be used when
14994   # locating libraries. On macosx, it's empty, though.
14995   OPENJDK_TARGET_CPU_LIBDIR="/$OPENJDK_TARGET_CPU_LEGACY_LIB"
14996   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
14997     OPENJDK_TARGET_CPU_LIBDIR=""
14998   fi
14999 
15000 
15001   # OPENJDK_TARGET_CPU_ISADIR is normally empty. On 64-bit Solaris systems, it is set to
15002   # /amd64 or /sparcv9. This string is appended to some library paths, like this:
15003   # /usr/lib${OPENJDK_TARGET_CPU_ISADIR}/libexample.so
15004   OPENJDK_TARGET_CPU_ISADIR=""
15005   if test "x$OPENJDK_TARGET_OS" = xsolaris; then
15006     if test "x$OPENJDK_TARGET_CPU" = xx86_64; then
15007       OPENJDK_TARGET_CPU_ISADIR="/amd64"
15008     elif test "x$OPENJDK_TARGET_CPU" = xsparcv9; then
15009       OPENJDK_TARGET_CPU_ISADIR="/sparcv9"
15010     fi
15011   fi
15012 
15013 
15014   # Setup OPENJDK_TARGET_CPU_OSARCH, which is used to set the os.arch Java system property
15015   OPENJDK_TARGET_CPU_OSARCH="$OPENJDK_TARGET_CPU"
15016   if test "x$OPENJDK_TARGET_OS" = xlinux && test "x$OPENJDK_TARGET_CPU" = xx86; then
15017     # On linux only, we replace x86 with i386.
15018     OPENJDK_TARGET_CPU_OSARCH="i386"
15019   elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
15020     # On all platforms except macosx, we replace x86_64 with amd64.
15021     OPENJDK_TARGET_CPU_OSARCH="amd64"
15022   fi
15023 
15024 
15025   OPENJDK_TARGET_CPU_JLI="$OPENJDK_TARGET_CPU"
15026   if test "x$OPENJDK_TARGET_CPU" = xx86; then
15027     OPENJDK_TARGET_CPU_JLI="i386"
15028   elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
15029     # On all platforms except macosx, we replace x86_64 with amd64.
15030     OPENJDK_TARGET_CPU_JLI="amd64"
15031   fi
15032   # Now setup the -D flags for building libjli.
15033   OPENJDK_TARGET_CPU_JLI_CFLAGS="-DLIBARCHNAME='\"$OPENJDK_TARGET_CPU_JLI\"'"
15034   if test "x$OPENJDK_TARGET_OS" = xsolaris; then
15035     if test "x$OPENJDK_TARGET_CPU_ARCH" = xsparc; then
15036       OPENJDK_TARGET_CPU_JLI_CFLAGS="$OPENJDK_TARGET_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"sparc\"' -DLIBARCH64NAME='\"sparcv9\"'"
15037     elif test "x$OPENJDK_TARGET_CPU_ARCH" = xx86; then
15038       OPENJDK_TARGET_CPU_JLI_CFLAGS="$OPENJDK_TARGET_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"i386\"' -DLIBARCH64NAME='\"amd64\"'"
15039     fi
15040   fi
15041 
15042 
15043   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
15044       OPENJDK_TARGET_OS_EXPORT_DIR=macosx
15045   else
15046       OPENJDK_TARGET_OS_EXPORT_DIR=${OPENJDK_TARGET_OS_TYPE}
15047   fi
15048 
15049 
15050   if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
15051     A_LP64="LP64:="
15052     # -D_LP64=1 is only set on linux and mac. Setting on windows causes diff in
15053     # unpack200.exe
15054     if test "x$OPENJDK_TARGET_OS" = xlinux || test "x$OPENJDK_TARGET_OS" = xmacosx; then
15055       ADD_LP64="-D_LP64=1"
15056     fi
15057   fi
15058   LP64=$A_LP64
15059 
15060 
15061   if test "x$COMPILE_TYPE" = "xcross"; then
15062     # FIXME: ... or should this include reduced builds..?
15063     DEFINE_CROSS_COMPILE_ARCH="CROSS_COMPILE_ARCH:=$OPENJDK_TARGET_CPU_LEGACY"
15064   else
15065     DEFINE_CROSS_COMPILE_ARCH=""
15066   fi
15067 
15068 
15069   # ZERO_ARCHDEF is used to enable architecture-specific code
15070   case "${OPENJDK_TARGET_CPU}" in
15071     ppc)     ZERO_ARCHDEF=PPC32 ;;
15072     ppc64)   ZERO_ARCHDEF=PPC64 ;;
15073     s390*)   ZERO_ARCHDEF=S390  ;;
15074     sparc*)  ZERO_ARCHDEF=SPARC ;;
15075     x86_64*) ZERO_ARCHDEF=AMD64 ;;
15076     x86)     ZERO_ARCHDEF=IA32  ;;
15077     *)      ZERO_ARCHDEF=$(echo "${OPENJDK_TARGET_CPU_LEGACY_LIB}" | tr a-z A-Z)
15078   esac
15079 
15080 
15081 
15082 
15083 # Continue setting up basic stuff. Most remaining code require fundamental tools.
15084 
15085   # Save the current directory this script was started from
15086   CURDIR="$PWD"
15087 
15088   # We might need to rewrite ORIGINAL_PATH, if it includes "#", to quote them
15089   # for make. We couldn't do this when we retrieved ORIGINAL_PATH, since SED
15090   # was not available at that time.
15091   REWRITTEN_PATH=`$ECHO "$ORIGINAL_PATH" | $SED -e 's/#/\\\\#/g'`
15092   if test "x$REWRITTEN_PATH" != "x$ORIGINAL_PATH"; then
15093     ORIGINAL_PATH="$REWRITTEN_PATH"
15094     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting ORIGINAL_PATH to $REWRITTEN_PATH" >&5
15095 $as_echo "$as_me: Rewriting ORIGINAL_PATH to $REWRITTEN_PATH" >&6;}
15096   fi
15097 
15098   if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
15099     PATH_SEP=";"
15100 
15101   SRC_ROOT_LENGTH=`$THEPWDCMD -L|$WC -m`
15102   if test $SRC_ROOT_LENGTH -gt 100; then
15103     as_fn_error $? "Your base path is too long. It is $SRC_ROOT_LENGTH characters long, but only 100 is supported" "$LINENO" 5
15104   fi
15105 
15106   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15107     { $as_echo "$as_me:${as_lineno-$LINENO}: checking cygwin release" >&5
15108 $as_echo_n "checking cygwin release... " >&6; }
15109     CYGWIN_VERSION=`$UNAME -r`
15110     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_VERSION" >&5
15111 $as_echo "$CYGWIN_VERSION" >&6; }
15112     WINDOWS_ENV_VENDOR='cygwin'
15113     WINDOWS_ENV_VERSION="$CYGWIN_VERSION"
15114 
15115     CYGWIN_VERSION_OLD=`$ECHO $CYGWIN_VERSION | $GREP -e '^1\.0-6'`
15116     if test "x$CYGWIN_VERSION_OLD" != x; then
15117       { $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
15118 $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;}
15119       as_fn_error $? "Cannot continue" "$LINENO" 5
15120     fi
15121     if test "x$CYGPATH" = x; then
15122       as_fn_error $? "Something is wrong with your cygwin installation since I cannot find cygpath.exe in your path" "$LINENO" 5
15123     fi
15124     { $as_echo "$as_me:${as_lineno-$LINENO}: checking cygwin root directory as unix-style path" >&5
15125 $as_echo_n "checking cygwin root directory as unix-style path... " >&6; }
15126     # The cmd output ends with Windows line endings (CR/LF), the grep command will strip that away
15127     cygwin_winpath_root=`cd / ; cmd /c cd | grep ".*"`
15128     # Force cygpath to report the proper root by including a trailing space, and then stripping it off again.
15129     CYGWIN_ROOT_PATH=`$CYGPATH -u "$cygwin_winpath_root " | $CUT -f 1 -d " "`
15130     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_ROOT_PATH" >&5
15131 $as_echo "$CYGWIN_ROOT_PATH" >&6; }
15132     WINDOWS_ENV_ROOT_PATH="$CYGWIN_ROOT_PATH"
15133     test_cygdrive_prefix=`$ECHO $CYGWIN_ROOT_PATH | $GREP ^/cygdrive/`
15134     if test "x$test_cygdrive_prefix" = x; then
15135       as_fn_error $? "Your cygdrive prefix is not /cygdrive. This is currently not supported. Change with mount -c." "$LINENO" 5
15136     fi
15137   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15138     { $as_echo "$as_me:${as_lineno-$LINENO}: checking msys release" >&5
15139 $as_echo_n "checking msys release... " >&6; }
15140     MSYS_VERSION=`$UNAME -r`
15141     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSYS_VERSION" >&5
15142 $as_echo "$MSYS_VERSION" >&6; }
15143 
15144     WINDOWS_ENV_VENDOR='msys'
15145     WINDOWS_ENV_VERSION="$MSYS_VERSION"
15146 
15147     { $as_echo "$as_me:${as_lineno-$LINENO}: checking msys root directory as unix-style path" >&5
15148 $as_echo_n "checking msys root directory as unix-style path... " >&6; }
15149     # The cmd output ends with Windows line endings (CR/LF), the grep command will strip that away
15150     MSYS_ROOT_PATH=`cd / ; cmd /c cd | grep ".*"`
15151 
15152   windows_path="$MSYS_ROOT_PATH"
15153   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15154     unix_path=`$CYGPATH -u "$windows_path"`
15155     MSYS_ROOT_PATH="$unix_path"
15156   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15157     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15158     MSYS_ROOT_PATH="$unix_path"
15159   fi
15160 
15161     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSYS_ROOT_PATH" >&5
15162 $as_echo "$MSYS_ROOT_PATH" >&6; }
15163     WINDOWS_ENV_ROOT_PATH="$MSYS_ROOT_PATH"
15164   else
15165     as_fn_error $? "Unknown Windows environment. Neither cygwin nor msys was detected." "$LINENO" 5
15166   fi
15167 
15168   # Test if windows or unix (cygwin/msys) find is first in path.
15169   { $as_echo "$as_me:${as_lineno-$LINENO}: checking what kind of 'find' is first on the PATH" >&5
15170 $as_echo_n "checking what kind of 'find' is first on the PATH... " >&6; }
15171   FIND_BINARY_OUTPUT=`find --version 2>&1`
15172   if test "x`echo $FIND_BINARY_OUTPUT | $GREP GNU`" != x; then
15173     { $as_echo "$as_me:${as_lineno-$LINENO}: result: unix style" >&5
15174 $as_echo "unix style" >&6; }
15175   elif test "x`echo $FIND_BINARY_OUTPUT | $GREP FIND`" != x; then
15176     { $as_echo "$as_me:${as_lineno-$LINENO}: result: Windows" >&5
15177 $as_echo "Windows" >&6; }
15178     { $as_echo "$as_me:${as_lineno-$LINENO}: Your path contains Windows tools (C:\Windows\system32) before your unix (cygwin or msys) tools." >&5
15179 $as_echo "$as_me: Your path contains Windows tools (C:\Windows\system32) before your unix (cygwin or msys) tools." >&6;}
15180     { $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
15181 $as_echo "$as_me: This will not work. Please correct and make sure /usr/bin (or similar) is first in path." >&6;}
15182     as_fn_error $? "Cannot continue" "$LINENO" 5
15183   else
15184     { $as_echo "$as_me:${as_lineno-$LINENO}: result: unknown" >&5
15185 $as_echo "unknown" >&6; }
15186     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: It seems that your find utility is non-standard." >&5
15187 $as_echo "$as_me: WARNING: It seems that your find utility is non-standard." >&2;}
15188   fi
15189 
15190   else
15191     PATH_SEP=":"
15192   fi
15193 
15194 
15195   # We get the top-level directory from the supporting wrappers.
15196   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for top-level directory" >&5
15197 $as_echo_n "checking for top-level directory... " >&6; }
15198   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOPDIR" >&5
15199 $as_echo "$TOPDIR" >&6; }
15200 
15201 
15202   # Save the original version of TOPDIR for string comparisons
15203   ORIGINAL_TOPDIR="$TOPDIR"
15204 
15205 
15206   # We can only call BASIC_FIXUP_PATH after BASIC_CHECK_PATHS_WINDOWS.
15207 
15208   # Only process if variable expands to non-empty
15209 
15210   if test "x$CURDIR" != x; then
15211     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15212 
15213   # Input might be given as Windows format, start by converting to
15214   # unix format.
15215   path="$CURDIR"
15216   new_path=`$CYGPATH -u "$path"`
15217 
15218   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
15219   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
15220   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
15221   # "foo.exe" is OK but "foo" is an error.
15222   #
15223   # This test is therefore slightly more accurate than "test -f" to check for file precense.
15224   # It is also a way to make sure we got the proper file name for the real test later on.
15225   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
15226   if test "x$test_shortpath" = x; then
15227     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CURDIR, which resolves as \"$path\", is invalid." >&5
15228 $as_echo "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid." >&6;}
15229     as_fn_error $? "Cannot locate the the path of CURDIR" "$LINENO" 5
15230   fi
15231 
15232   # Call helper function which possibly converts this using DOS-style short mode.
15233   # If so, the updated path is stored in $new_path.
15234 
15235   input_path="$new_path"
15236   # Check if we need to convert this using DOS-style short mode. If the path
15237   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15238   # take no chances and rewrite it.
15239   # Note: m4 eats our [], so we need to use [ and ] instead.
15240   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
15241   if test "x$has_forbidden_chars" != x; then
15242     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15243     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
15244     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
15245     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
15246       # Going to short mode and back again did indeed matter. Since short mode is
15247       # case insensitive, let's make it lowercase to improve readability.
15248       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15249       # Now convert it back to Unix-style (cygpath)
15250       input_path=`$CYGPATH -u "$shortmode_path"`
15251       new_path="$input_path"
15252     fi
15253   fi
15254 
15255   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
15256   if test "x$test_cygdrive_prefix" = x; then
15257     # As a simple fix, exclude /usr/bin since it's not a real path.
15258     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
15259       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
15260       # a path prefixed by /cygdrive for fixpath to work.
15261       new_path="$CYGWIN_ROOT_PATH$input_path"
15262     fi
15263   fi
15264 
15265 
15266   if test "x$path" != "x$new_path"; then
15267     CURDIR="$new_path"
15268     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
15269 $as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
15270   fi
15271 
15272     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15273 
15274   path="$CURDIR"
15275   has_colon=`$ECHO $path | $GREP ^.:`
15276   new_path="$path"
15277   if test "x$has_colon" = x; then
15278     # Not in mixed or Windows style, start by that.
15279     new_path=`cmd //c echo $path`
15280   fi
15281 
15282 
15283   input_path="$new_path"
15284   # Check if we need to convert this using DOS-style short mode. If the path
15285   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15286   # take no chances and rewrite it.
15287   # Note: m4 eats our [], so we need to use [ and ] instead.
15288   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
15289   if test "x$has_forbidden_chars" != x; then
15290     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15291     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15292   fi
15293 
15294 
15295   windows_path="$new_path"
15296   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15297     unix_path=`$CYGPATH -u "$windows_path"`
15298     new_path="$unix_path"
15299   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15300     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15301     new_path="$unix_path"
15302   fi
15303 
15304   if test "x$path" != "x$new_path"; then
15305     CURDIR="$new_path"
15306     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
15307 $as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
15308   fi
15309 
15310   # Save the first 10 bytes of this path to the storage, so fixpath can work.
15311   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
15312 
15313     else
15314       # We're on a unix platform. Hooray! :)
15315       path="$CURDIR"
15316       has_space=`$ECHO "$path" | $GREP " "`
15317       if test "x$has_space" != x; then
15318         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CURDIR, which resolves as \"$path\", is invalid." >&5
15319 $as_echo "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid." >&6;}
15320         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
15321       fi
15322 
15323       # Use eval to expand a potential ~
15324       eval path="$path"
15325       if test ! -f "$path" && test ! -d "$path"; then
15326         as_fn_error $? "The path of CURDIR, which resolves as \"$path\", is not found." "$LINENO" 5
15327       fi
15328 
15329       CURDIR="`cd "$path"; $THEPWDCMD -L`"
15330     fi
15331   fi
15332 
15333 
15334   # Only process if variable expands to non-empty
15335 
15336   if test "x$TOPDIR" != x; then
15337     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15338 
15339   # Input might be given as Windows format, start by converting to
15340   # unix format.
15341   path="$TOPDIR"
15342   new_path=`$CYGPATH -u "$path"`
15343 
15344   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
15345   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
15346   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
15347   # "foo.exe" is OK but "foo" is an error.
15348   #
15349   # This test is therefore slightly more accurate than "test -f" to check for file precense.
15350   # It is also a way to make sure we got the proper file name for the real test later on.
15351   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
15352   if test "x$test_shortpath" = x; then
15353     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of TOPDIR, which resolves as \"$path\", is invalid." >&5
15354 $as_echo "$as_me: The path of TOPDIR, which resolves as \"$path\", is invalid." >&6;}
15355     as_fn_error $? "Cannot locate the the path of TOPDIR" "$LINENO" 5
15356   fi
15357 
15358   # Call helper function which possibly converts this using DOS-style short mode.
15359   # If so, the updated path is stored in $new_path.
15360 
15361   input_path="$new_path"
15362   # Check if we need to convert this using DOS-style short mode. If the path
15363   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15364   # take no chances and rewrite it.
15365   # Note: m4 eats our [], so we need to use [ and ] instead.
15366   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
15367   if test "x$has_forbidden_chars" != x; then
15368     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15369     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
15370     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
15371     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
15372       # Going to short mode and back again did indeed matter. Since short mode is
15373       # case insensitive, let's make it lowercase to improve readability.
15374       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15375       # Now convert it back to Unix-style (cygpath)
15376       input_path=`$CYGPATH -u "$shortmode_path"`
15377       new_path="$input_path"
15378     fi
15379   fi
15380 
15381   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
15382   if test "x$test_cygdrive_prefix" = x; then
15383     # As a simple fix, exclude /usr/bin since it's not a real path.
15384     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
15385       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
15386       # a path prefixed by /cygdrive for fixpath to work.
15387       new_path="$CYGWIN_ROOT_PATH$input_path"
15388     fi
15389   fi
15390 
15391 
15392   if test "x$path" != "x$new_path"; then
15393     TOPDIR="$new_path"
15394     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting TOPDIR to \"$new_path\"" >&5
15395 $as_echo "$as_me: Rewriting TOPDIR to \"$new_path\"" >&6;}
15396   fi
15397 
15398     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15399 
15400   path="$TOPDIR"
15401   has_colon=`$ECHO $path | $GREP ^.:`
15402   new_path="$path"
15403   if test "x$has_colon" = x; then
15404     # Not in mixed or Windows style, start by that.
15405     new_path=`cmd //c echo $path`
15406   fi
15407 
15408 
15409   input_path="$new_path"
15410   # Check if we need to convert this using DOS-style short mode. If the path
15411   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15412   # take no chances and rewrite it.
15413   # Note: m4 eats our [], so we need to use [ and ] instead.
15414   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
15415   if test "x$has_forbidden_chars" != x; then
15416     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15417     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15418   fi
15419 
15420 
15421   windows_path="$new_path"
15422   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15423     unix_path=`$CYGPATH -u "$windows_path"`
15424     new_path="$unix_path"
15425   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15426     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15427     new_path="$unix_path"
15428   fi
15429 
15430   if test "x$path" != "x$new_path"; then
15431     TOPDIR="$new_path"
15432     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting TOPDIR to \"$new_path\"" >&5
15433 $as_echo "$as_me: Rewriting TOPDIR to \"$new_path\"" >&6;}
15434   fi
15435 
15436   # Save the first 10 bytes of this path to the storage, so fixpath can work.
15437   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
15438 
15439     else
15440       # We're on a unix platform. Hooray! :)
15441       path="$TOPDIR"
15442       has_space=`$ECHO "$path" | $GREP " "`
15443       if test "x$has_space" != x; then
15444         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of TOPDIR, which resolves as \"$path\", is invalid." >&5
15445 $as_echo "$as_me: The path of TOPDIR, which resolves as \"$path\", is invalid." >&6;}
15446         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
15447       fi
15448 
15449       # Use eval to expand a potential ~
15450       eval path="$path"
15451       if test ! -f "$path" && test ! -d "$path"; then
15452         as_fn_error $? "The path of TOPDIR, which resolves as \"$path\", is not found." "$LINENO" 5
15453       fi
15454 
15455       TOPDIR="`cd "$path"; $THEPWDCMD -L`"
15456     fi
15457   fi
15458 
15459   # SRC_ROOT is a traditional alias for TOPDIR.
15460   SRC_ROOT=$TOPDIR
15461 
15462   # Calculate a canonical version of TOPDIR for string comparisons
15463   CANONICAL_TOPDIR=$TOPDIR
15464 
15465   if test "x$OPENJDK_BUILD_OS" != xwindows; then
15466     # Follow a chain of symbolic links. Use readlink
15467     # where it exists, else fall back to horribly
15468     # complicated shell code.
15469     if test "x$READLINK_TESTED" != yes; then
15470       # On MacOSX there is a readlink tool with a different
15471       # purpose than the GNU readlink tool. Check the found readlink.
15472       ISGNU=`$READLINK --version 2>&1 | $GREP GNU`
15473       if test "x$ISGNU" = x; then
15474         # A readlink that we do not know how to use.
15475         # Are there other non-GNU readlinks out there?
15476         READLINK_TESTED=yes
15477         READLINK=
15478       fi
15479     fi
15480 
15481     if test "x$READLINK" != x; then
15482       CANONICAL_TOPDIR=`$READLINK -f $CANONICAL_TOPDIR`
15483     else
15484       # Save the current directory for restoring afterwards
15485       STARTDIR=$PWD
15486       COUNTER=0
15487       sym_link_dir=`$DIRNAME $CANONICAL_TOPDIR`
15488       sym_link_file=`$BASENAME $CANONICAL_TOPDIR`
15489       cd $sym_link_dir
15490       # Use -P flag to resolve symlinks in directories.
15491       cd `$THEPWDCMD -P`
15492       sym_link_dir=`$THEPWDCMD -P`
15493       # Resolve file symlinks
15494       while test $COUNTER -lt 20; do
15495         ISLINK=`$LS -l $sym_link_dir/$sym_link_file | $GREP '\->' | $SED -e 's/.*-> \(.*\)/\1/'`
15496         if test "x$ISLINK" == x; then
15497           # This is not a symbolic link! We are done!
15498           break
15499         fi
15500         # Again resolve directory symlinks since the target of the just found
15501         # link could be in a different directory
15502         cd `$DIRNAME $ISLINK`
15503         sym_link_dir=`$THEPWDCMD -P`
15504         sym_link_file=`$BASENAME $ISLINK`
15505         let COUNTER=COUNTER+1
15506       done
15507       cd $STARTDIR
15508       CANONICAL_TOPDIR=$sym_link_dir/$sym_link_file
15509     fi
15510   fi
15511 
15512 
15513 
15514   # Locate the directory of this script.
15515   AUTOCONF_DIR=$TOPDIR/common/autoconf
15516 
15517 
15518 # Check if it's a pure open build or if custom sources are to be used.
15519 
15520   # Check whether --enable-openjdk-only was given.
15521 if test "${enable_openjdk_only+set}" = set; then :
15522   enableval=$enable_openjdk_only;
15523 else
15524   enable_openjdk_only="no"
15525 fi
15526 
15527 
15528   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for presence of closed sources" >&5
15529 $as_echo_n "checking for presence of closed sources... " >&6; }
15530   if test -d "$SRC_ROOT/jdk/src/closed"; then
15531     CLOSED_SOURCE_PRESENT=yes
15532   else
15533     CLOSED_SOURCE_PRESENT=no
15534   fi
15535   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CLOSED_SOURCE_PRESENT" >&5
15536 $as_echo "$CLOSED_SOURCE_PRESENT" >&6; }
15537 
15538   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if closed source is suppressed (openjdk-only)" >&5
15539 $as_echo_n "checking if closed source is suppressed (openjdk-only)... " >&6; }
15540   SUPPRESS_CLOSED_SOURCE="$enable_openjdk_only"
15541   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SUPPRESS_CLOSED_SOURCE" >&5
15542 $as_echo "$SUPPRESS_CLOSED_SOURCE" >&6; }
15543 
15544   if test "x$CLOSED_SOURCE_PRESENT" = xno; then
15545     OPENJDK=true
15546     if test "x$SUPPRESS_CLOSED_SOURCE" = "xyes"; then
15547       { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No closed source present, --enable-openjdk-only makes no sense" >&5
15548 $as_echo "$as_me: WARNING: No closed source present, --enable-openjdk-only makes no sense" >&2;}
15549     fi
15550   else
15551     if test "x$SUPPRESS_CLOSED_SOURCE" = "xyes"; then
15552       OPENJDK=true
15553     else
15554       OPENJDK=false
15555     fi
15556   fi
15557 
15558   if test "x$OPENJDK" = "xtrue"; then
15559     SET_OPENJDK="OPENJDK=true"
15560   fi
15561 
15562 
15563 
15564   # custom-make-dir is deprecated. Please use your custom-hook.m4 to override
15565   # the IncludeCustomExtension macro.
15566 
15567 
15568 # Check whether --with-custom-make-dir was given.
15569 if test "${with_custom_make_dir+set}" = set; then :
15570   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
15571 $as_echo "$as_me: WARNING: Option --with-custom-make-dir is deprecated and will be ignored." >&2;}
15572 fi
15573 
15574 
15575 
15576 
15577 # These are needed to be able to create a configuration name (and thus the output directory)
15578 
15579   ###############################################################################
15580   #
15581   # Check which variant of the JDK that we want to build.
15582   # Currently we have:
15583   #    normal:   standard edition
15584   # but the custom make system may add other variants
15585   #
15586   # Effectively the JDK variant gives a name to a specific set of
15587   # modules to compile into the JDK. In the future, these modules
15588   # might even be Jigsaw modules.
15589   #
15590   { $as_echo "$as_me:${as_lineno-$LINENO}: checking which variant of the JDK to build" >&5
15591 $as_echo_n "checking which variant of the JDK to build... " >&6; }
15592 
15593 # Check whether --with-jdk-variant was given.
15594 if test "${with_jdk_variant+set}" = set; then :
15595   withval=$with_jdk_variant;
15596 fi
15597 
15598 
15599   if test "x$with_jdk_variant" = xnormal || test "x$with_jdk_variant" = x; then
15600     JDK_VARIANT="normal"
15601   else
15602     as_fn_error $? "The available JDK variants are: normal" "$LINENO" 5
15603   fi
15604 
15605 
15606 
15607   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JDK_VARIANT" >&5
15608 $as_echo "$JDK_VARIANT" >&6; }
15609 
15610 
15611 ###############################################################################
15612 #
15613 # Check which interpreter of the JVM we want to build.
15614 # Currently we have:
15615 #    template: Template interpreter (the default)
15616 #    cpp     : C++ interpreter
15617 { $as_echo "$as_me:${as_lineno-$LINENO}: checking which interpreter of the JVM to build" >&5
15618 $as_echo_n "checking which interpreter of the JVM to build... " >&6; }
15619 
15620 # Check whether --with-jvm-interpreter was given.
15621 if test "${with_jvm_interpreter+set}" = set; then :
15622   withval=$with_jvm_interpreter;
15623 fi
15624 
15625 
15626 if test "x$with_jvm_interpreter" = x; then
15627      with_jvm_interpreter="template"
15628 fi
15629 
15630 JVM_INTERPRETER="$with_jvm_interpreter"
15631 
15632 if test "x$JVM_INTERPRETER" != xtemplate && test "x$JVM_INTERPRETER" != xcpp; then
15633    as_fn_error $? "The available JVM interpreters are: template, cpp" "$LINENO" 5
15634 fi
15635 
15636 
15637 
15638 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_jvm_interpreter" >&5
15639 $as_echo "$with_jvm_interpreter" >&6; }
15640 
15641 
15642 
15643   ###############################################################################
15644   #
15645   # Check which variants of the JVM that we want to build.
15646   # Currently we have:
15647   #    server: normal interpreter and a tiered C1/C2 compiler
15648   #    client: normal interpreter and C1 (no C2 compiler) (only 32-bit platforms)
15649   #    minimal1: reduced form of client with optional VM services and features stripped out
15650   #    kernel: kernel footprint JVM that passes the TCK without major performance problems,
15651   #             ie normal interpreter and C1, only the serial GC, kernel jvmti etc
15652   #    zero: no machine code interpreter, no compiler
15653   #    zeroshark: zero interpreter and shark/llvm compiler backend
15654 #    core: interpreter only, no compiler (only works on some platforms)
15655   { $as_echo "$as_me:${as_lineno-$LINENO}: checking which variants of the JVM to build" >&5
15656 $as_echo_n "checking which variants of the JVM to build... " >&6; }
15657 
15658 # Check whether --with-jvm-variants was given.
15659 if test "${with_jvm_variants+set}" = set; then :
15660   withval=$with_jvm_variants;
15661 fi
15662 
15663 
15664   if test "x$with_jvm_variants" = x; then
15665     with_jvm_variants="server"
15666   fi
15667 
15668   JVM_VARIANTS=",$with_jvm_variants,"
15669   TEST_VARIANTS=`$ECHO "$JVM_VARIANTS" | $SED -e 's/server,//' -e 's/client,//'  -e 's/minimal1,//' -e 's/kernel,//' -e 's/zero,//' -e 's/zeroshark,//' -e 's/core,//'`
15670 
15671   if test "x$TEST_VARIANTS" != "x,"; then
15672      as_fn_error $? "The available JVM variants are: server, client, minimal1, kernel, zero, zeroshark, core" "$LINENO" 5
15673   fi
15674   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_jvm_variants" >&5
15675 $as_echo "$with_jvm_variants" >&6; }
15676 
15677   JVM_VARIANT_SERVER=`$ECHO "$JVM_VARIANTS" | $SED -e '/,server,/!s/.*/false/g' -e '/,server,/s/.*/true/g'`
15678   JVM_VARIANT_CLIENT=`$ECHO "$JVM_VARIANTS" | $SED -e '/,client,/!s/.*/false/g' -e '/,client,/s/.*/true/g'`
15679   JVM_VARIANT_MINIMAL1=`$ECHO "$JVM_VARIANTS" | $SED -e '/,minimal1,/!s/.*/false/g' -e '/,minimal1,/s/.*/true/g'`
15680   JVM_VARIANT_KERNEL=`$ECHO "$JVM_VARIANTS" | $SED -e '/,kernel,/!s/.*/false/g' -e '/,kernel,/s/.*/true/g'`
15681   JVM_VARIANT_ZERO=`$ECHO "$JVM_VARIANTS" | $SED -e '/,zero,/!s/.*/false/g' -e '/,zero,/s/.*/true/g'`
15682   JVM_VARIANT_ZEROSHARK=`$ECHO "$JVM_VARIANTS" | $SED -e '/,zeroshark,/!s/.*/false/g' -e '/,zeroshark,/s/.*/true/g'`
15683   JVM_VARIANT_CORE=`$ECHO "$JVM_VARIANTS" | $SED -e '/,core,/!s/.*/false/g' -e '/,core,/s/.*/true/g'`
15684 
15685   if test "x$JVM_VARIANT_CLIENT" = xtrue; then
15686     if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
15687       as_fn_error $? "You cannot build a client JVM for a 64-bit machine." "$LINENO" 5
15688     fi
15689   fi
15690   if test "x$JVM_VARIANT_KERNEL" = xtrue; then
15691     if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
15692       as_fn_error $? "You cannot build a kernel JVM for a 64-bit machine." "$LINENO" 5
15693     fi
15694   fi
15695   if test "x$JVM_VARIANT_MINIMAL1" = xtrue; then
15696     if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
15697       as_fn_error $? "You cannot build a minimal JVM for a 64-bit machine." "$LINENO" 5
15698     fi
15699   fi
15700 
15701   # Replace the commas with AND for use in the build directory name.
15702   ANDED_JVM_VARIANTS=`$ECHO "$JVM_VARIANTS" | $SED -e 's/^,//' -e 's/,$//' -e 's/,/AND/g'`
15703   COUNT_VARIANTS=`$ECHO "$JVM_VARIANTS" | $SED -e 's/server,/1/' -e 's/client,/1/' -e 's/minimal1,/1/' -e 's/kernel,/1/' -e 's/zero,/1/' -e 's/zeroshark,/1/' -e 's/core,/1/'`
15704   if test "x$COUNT_VARIANTS" != "x,1"; then
15705     BUILDING_MULTIPLE_JVM_VARIANTS=yes
15706   else
15707     BUILDING_MULTIPLE_JVM_VARIANTS=no
15708   fi
15709 
15710 
15711 
15712 
15713 
15714 
15715 
15716 
15717 
15718 
15719   INCLUDE_SA=true
15720   if test "x$JVM_VARIANT_ZERO" = xtrue ; then
15721     INCLUDE_SA=false
15722   fi
15723   if test "x$JVM_VARIANT_ZEROSHARK" = xtrue ; then
15724     INCLUDE_SA=false
15725   fi
15726   if test "x$OPENJDK_TARGET_OS" = xaix ; then
15727     INCLUDE_SA=false
15728   fi
15729   if test "x$OPENJDK_TARGET_CPU" = xaarch64; then
15730     INCLUDE_SA=false
15731   fi
15732 
15733 
15734   if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
15735     MACOSX_UNIVERSAL="true"
15736   fi
15737 
15738 
15739 
15740 
15741   ###############################################################################
15742   #
15743   # Set the debug level
15744   #    release: no debug information, all optimizations, no asserts.
15745   #    optimized: no debug information, all optimizations, no asserts, HotSpot target is 'optimized'.
15746   #    fastdebug: debug information (-g), all optimizations, all asserts
15747   #    slowdebug: debug information (-g), no optimizations, all asserts
15748   #
15749   DEBUG_LEVEL="release"
15750   { $as_echo "$as_me:${as_lineno-$LINENO}: checking which debug level to use" >&5
15751 $as_echo_n "checking which debug level to use... " >&6; }
15752   # Check whether --enable-debug was given.
15753 if test "${enable_debug+set}" = set; then :
15754   enableval=$enable_debug;
15755         ENABLE_DEBUG="${enableval}"
15756         DEBUG_LEVEL="fastdebug"
15757 
15758 else
15759   ENABLE_DEBUG="no"
15760 fi
15761 
15762 
15763 
15764 # Check whether --with-debug-level was given.
15765 if test "${with_debug_level+set}" = set; then :
15766   withval=$with_debug_level;
15767         DEBUG_LEVEL="${withval}"
15768         if test "x$ENABLE_DEBUG" = xyes; then
15769           as_fn_error $? "You cannot use both --enable-debug and --with-debug-level at the same time." "$LINENO" 5
15770         fi
15771 
15772 fi
15773 
15774   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEBUG_LEVEL" >&5
15775 $as_echo "$DEBUG_LEVEL" >&6; }
15776 
15777   if test "x$DEBUG_LEVEL" != xrelease && \
15778       test "x$DEBUG_LEVEL" != xoptimized && \
15779       test "x$DEBUG_LEVEL" != xfastdebug && \
15780       test "x$DEBUG_LEVEL" != xslowdebug; then
15781     as_fn_error $? "Allowed debug levels are: release, fastdebug and slowdebug" "$LINENO" 5
15782   fi
15783 
15784 
15785   ###############################################################################
15786   #
15787   # Setup legacy vars/targets and new vars to deal with different debug levels.
15788   #
15789 
15790   case $DEBUG_LEVEL in
15791     release )
15792       VARIANT="OPT"
15793       FASTDEBUG="false"
15794       DEBUG_CLASSFILES="false"
15795       BUILD_VARIANT_RELEASE=""
15796       HOTSPOT_DEBUG_LEVEL="product"
15797       HOTSPOT_EXPORT="product"
15798       ;;
15799     fastdebug )
15800       VARIANT="DBG"
15801       FASTDEBUG="true"
15802       DEBUG_CLASSFILES="true"
15803       BUILD_VARIANT_RELEASE="-fastdebug"
15804       HOTSPOT_DEBUG_LEVEL="fastdebug"
15805       HOTSPOT_EXPORT="fastdebug"
15806       ;;
15807     slowdebug )
15808       VARIANT="DBG"
15809       FASTDEBUG="false"
15810       DEBUG_CLASSFILES="true"
15811       BUILD_VARIANT_RELEASE="-debug"
15812       HOTSPOT_DEBUG_LEVEL="debug"
15813       HOTSPOT_EXPORT="debug"
15814       ;;
15815     optimized )
15816       VARIANT="OPT"
15817       FASTDEBUG="false"
15818       DEBUG_CLASSFILES="false"
15819       BUILD_VARIANT_RELEASE="-optimized"
15820       HOTSPOT_DEBUG_LEVEL="optimized"
15821       HOTSPOT_EXPORT="optimized"
15822       ;;
15823   esac
15824 
15825   # The debug level 'optimized' is a little special because it is currently only
15826   # applicable to the HotSpot build where it means to build a completely
15827   # optimized version of the VM without any debugging code (like for the
15828   # 'release' debug level which is called 'product' in the HotSpot build) but
15829   # with the exception that it can contain additional code which is otherwise
15830   # protected by '#ifndef PRODUCT' macros. These 'optimized' builds are used to
15831   # test new and/or experimental features which are not intended for customer
15832   # shipment. Because these new features need to be tested and benchmarked in
15833   # real world scenarios, we want to build the containing JDK at the 'release'
15834   # debug level.
15835   if test "x$DEBUG_LEVEL" = xoptimized; then
15836     DEBUG_LEVEL="release"
15837   fi
15838 
15839   #####
15840   # Generate the legacy makefile targets for hotspot.
15841   # The hotspot api for selecting the build artifacts, really, needs to be improved.
15842   # JDK-7195896 will fix this on the hotspot side by using the JVM_VARIANT_* variables to
15843   # determine what needs to be built. All we will need to set here is all_product, all_fastdebug etc
15844   # But until then ...
15845   HOTSPOT_TARGET=""
15846 
15847   if test "x$JVM_VARIANT_SERVER" = xtrue; then
15848     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL} "
15849   fi
15850 
15851   if test "x$JVM_VARIANT_CLIENT" = xtrue; then
15852     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}1 "
15853   fi
15854 
15855   if test "x$JVM_VARIANT_MINIMAL1" = xtrue; then
15856     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}minimal1 "
15857   fi
15858 
15859   if test "x$JVM_VARIANT_KERNEL" = xtrue; then
15860     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}kernel "
15861   fi
15862 
15863   if test "x$JVM_VARIANT_ZERO" = xtrue; then
15864     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}zero "
15865   fi
15866 
15867   if test "x$JVM_VARIANT_ZEROSHARK" = xtrue; then
15868     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}shark "
15869   fi
15870 
15871   if test "x$JVM_VARIANT_CORE" = xtrue; then
15872     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}core "
15873   fi
15874 
15875   HOTSPOT_TARGET="$HOTSPOT_TARGET docs export_$HOTSPOT_EXPORT"
15876 
15877   # On Macosx universal binaries are produced, but they only contain
15878   # 64 bit intel. This invalidates control of which jvms are built
15879   # from configure, but only server is valid anyway. Fix this
15880   # when hotspot makefiles are rewritten.
15881   if test "x$MACOSX_UNIVERSAL" = xtrue; then
15882     HOTSPOT_TARGET=universal_${HOTSPOT_EXPORT}
15883   fi
15884 
15885   #####
15886 
15887 
15888 
15889 
15890 
15891 
15892 
15893 
15894 # With basic setup done, call the custom early hook.
15895 
15896 
15897 # Check if we have devkits, extra paths or sysroot set.
15898 
15899 
15900 # Check whether --with-devkit was given.
15901 if test "${with_devkit+set}" = set; then :
15902   withval=$with_devkit;
15903 
15904   # Only process if variable expands to non-empty
15905 
15906   if test "x$with_devkit" != x; then
15907     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15908 
15909   # Input might be given as Windows format, start by converting to
15910   # unix format.
15911   path="$with_devkit"
15912   new_path=`$CYGPATH -u "$path"`
15913 
15914   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
15915   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
15916   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
15917   # "foo.exe" is OK but "foo" is an error.
15918   #
15919   # This test is therefore slightly more accurate than "test -f" to check for file precense.
15920   # It is also a way to make sure we got the proper file name for the real test later on.
15921   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
15922   if test "x$test_shortpath" = x; then
15923     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
15924 $as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
15925     as_fn_error $? "Cannot locate the the path of with_devkit" "$LINENO" 5
15926   fi
15927 
15928   # Call helper function which possibly converts this using DOS-style short mode.
15929   # If so, the updated path is stored in $new_path.
15930 
15931   input_path="$new_path"
15932   # Check if we need to convert this using DOS-style short mode. If the path
15933   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15934   # take no chances and rewrite it.
15935   # Note: m4 eats our [], so we need to use [ and ] instead.
15936   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
15937   if test "x$has_forbidden_chars" != x; then
15938     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15939     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
15940     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
15941     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
15942       # Going to short mode and back again did indeed matter. Since short mode is
15943       # case insensitive, let's make it lowercase to improve readability.
15944       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15945       # Now convert it back to Unix-style (cygpath)
15946       input_path=`$CYGPATH -u "$shortmode_path"`
15947       new_path="$input_path"
15948     fi
15949   fi
15950 
15951   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
15952   if test "x$test_cygdrive_prefix" = x; then
15953     # As a simple fix, exclude /usr/bin since it's not a real path.
15954     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
15955       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
15956       # a path prefixed by /cygdrive for fixpath to work.
15957       new_path="$CYGWIN_ROOT_PATH$input_path"
15958     fi
15959   fi
15960 
15961 
15962   if test "x$path" != "x$new_path"; then
15963     with_devkit="$new_path"
15964     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
15965 $as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
15966   fi
15967 
15968     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15969 
15970   path="$with_devkit"
15971   has_colon=`$ECHO $path | $GREP ^.:`
15972   new_path="$path"
15973   if test "x$has_colon" = x; then
15974     # Not in mixed or Windows style, start by that.
15975     new_path=`cmd //c echo $path`
15976   fi
15977 
15978 
15979   input_path="$new_path"
15980   # Check if we need to convert this using DOS-style short mode. If the path
15981   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15982   # take no chances and rewrite it.
15983   # Note: m4 eats our [], so we need to use [ and ] instead.
15984   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
15985   if test "x$has_forbidden_chars" != x; then
15986     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15987     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15988   fi
15989 
15990 
15991   windows_path="$new_path"
15992   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15993     unix_path=`$CYGPATH -u "$windows_path"`
15994     new_path="$unix_path"
15995   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15996     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15997     new_path="$unix_path"
15998   fi
15999 
16000   if test "x$path" != "x$new_path"; then
16001     with_devkit="$new_path"
16002     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
16003 $as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
16004   fi
16005 
16006   # Save the first 10 bytes of this path to the storage, so fixpath can work.
16007   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
16008 
16009     else
16010       # We're on a unix platform. Hooray! :)
16011       path="$with_devkit"
16012       has_space=`$ECHO "$path" | $GREP " "`
16013       if test "x$has_space" != x; then
16014         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
16015 $as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
16016         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
16017       fi
16018 
16019       # Use eval to expand a potential ~
16020       eval path="$path"
16021       if test ! -f "$path" && test ! -d "$path"; then
16022         as_fn_error $? "The path of with_devkit, which resolves as \"$path\", is not found." "$LINENO" 5
16023       fi
16024 
16025       with_devkit="`cd "$path"; $THEPWDCMD -L`"
16026     fi
16027   fi
16028 
16029         DEVKIT_ROOT="$with_devkit"
16030         # Check for a meta data info file in the root of the devkit
16031         if test -f "$DEVKIT_ROOT/devkit.info"; then
16032           . $DEVKIT_ROOT/devkit.info
16033           # This potentially sets the following:
16034           # A descriptive name of the devkit
16035 
16036   if test "x$DEVKIT_NAME" = x; then
16037     eval DEVKIT_NAME="\${DEVKIT_NAME_${OPENJDK_TARGET_CPU}}"
16038   fi
16039 
16040           # Corresponds to --with-extra-path
16041 
16042   if test "x$DEVKIT_EXTRA_PATH" = x; then
16043     eval DEVKIT_EXTRA_PATH="\${DEVKIT_EXTRA_PATH_${OPENJDK_TARGET_CPU}}"
16044   fi
16045 
16046           # Corresponds to --with-toolchain-path
16047 
16048   if test "x$DEVKIT_TOOLCHAIN_PATH" = x; then
16049     eval DEVKIT_TOOLCHAIN_PATH="\${DEVKIT_TOOLCHAIN_PATH_${OPENJDK_TARGET_CPU}}"
16050   fi
16051 
16052           # Corresponds to --with-sysroot
16053 
16054   if test "x$DEVKIT_SYSROOT" = x; then
16055     eval DEVKIT_SYSROOT="\${DEVKIT_SYSROOT_${OPENJDK_TARGET_CPU}}"
16056   fi
16057 
16058 
16059           # Identifies the Visual Studio version in the devkit
16060 
16061   if test "x$DEVKIT_VS_VERSION" = x; then
16062     eval DEVKIT_VS_VERSION="\${DEVKIT_VS_VERSION_${OPENJDK_TARGET_CPU}}"
16063   fi
16064 
16065           # The Visual Studio include environment variable
16066 
16067   if test "x$DEVKIT_VS_INCLUDE" = x; then
16068     eval DEVKIT_VS_INCLUDE="\${DEVKIT_VS_INCLUDE_${OPENJDK_TARGET_CPU}}"
16069   fi
16070 
16071           # The Visual Studio lib environment variable
16072 
16073   if test "x$DEVKIT_VS_LIB" = x; then
16074     eval DEVKIT_VS_LIB="\${DEVKIT_VS_LIB_${OPENJDK_TARGET_CPU}}"
16075   fi
16076 
16077           # Corresponds to --with-msvcr-dll
16078 
16079   if test "x$DEVKIT_MSVCR_DLL" = x; then
16080     eval DEVKIT_MSVCR_DLL="\${DEVKIT_MSVCR_DLL_${OPENJDK_TARGET_CPU}}"
16081   fi
16082 
16083           # Corresponds to --with-msvcp-dll
16084 
16085   if test "x$DEVKIT_MSVCP_DLL" = x; then
16086     eval DEVKIT_MSVCP_DLL="\${DEVKIT_MSVCP_DLL_${OPENJDK_TARGET_CPU}}"
16087   fi
16088 
16089         fi
16090 
16091         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for devkit" >&5
16092 $as_echo_n "checking for devkit... " >&6; }
16093         if test "x$DEVKIT_NAME" != x; then
16094           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEVKIT_NAME in $DEVKIT_ROOT" >&5
16095 $as_echo "$DEVKIT_NAME in $DEVKIT_ROOT" >&6; }
16096         else
16097           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEVKIT_ROOT" >&5
16098 $as_echo "$DEVKIT_ROOT" >&6; }
16099         fi
16100 
16101 
16102   if test "x$DEVKIT_EXTRA_PATH" != x; then
16103     if test "x$EXTRA_PATH" = x; then
16104       EXTRA_PATH="$DEVKIT_EXTRA_PATH"
16105     else
16106       EXTRA_PATH="$DEVKIT_EXTRA_PATH:$EXTRA_PATH"
16107     fi
16108   fi
16109 
16110 
16111         # Fallback default of just /bin if DEVKIT_PATH is not defined
16112         if test "x$DEVKIT_TOOLCHAIN_PATH" = x; then
16113           DEVKIT_TOOLCHAIN_PATH="$DEVKIT_ROOT/bin"
16114         fi
16115 
16116   if test "x$DEVKIT_TOOLCHAIN_PATH" != x; then
16117     if test "x$TOOLCHAIN_PATH" = x; then
16118       TOOLCHAIN_PATH="$DEVKIT_TOOLCHAIN_PATH"
16119     else
16120       TOOLCHAIN_PATH="$DEVKIT_TOOLCHAIN_PATH:$TOOLCHAIN_PATH"
16121     fi
16122   fi
16123 
16124 
16125         # If DEVKIT_SYSROOT is set, use that, otherwise try a couple of known
16126         # places for backwards compatiblity.
16127         if test "x$DEVKIT_SYSROOT" != x; then
16128           SYSROOT="$DEVKIT_SYSROOT"
16129         elif test -d "$DEVKIT_ROOT/$host_alias/libc"; then
16130           SYSROOT="$DEVKIT_ROOT/$host_alias/libc"
16131         elif test -d "$DEVKIT_ROOT/$host/sys-root"; then
16132           SYSROOT="$DEVKIT_ROOT/$host/sys-root"
16133         fi
16134 
16135 
16136 fi
16137 
16138 
16139   # You can force the sysroot if the sysroot encoded into the compiler tools
16140   # is not correct.
16141 
16142 # Check whether --with-sys-root was given.
16143 if test "${with_sys_root+set}" = set; then :
16144   withval=$with_sys_root; SYSROOT=$with_sys_root
16145 
16146 fi
16147 
16148 
16149 
16150 # Check whether --with-sysroot was given.
16151 if test "${with_sysroot+set}" = set; then :
16152   withval=$with_sysroot; SYSROOT=$with_sysroot
16153 
16154 fi
16155 
16156 
16157 
16158 # Check whether --with-tools-dir was given.
16159 if test "${with_tools_dir+set}" = set; then :
16160   withval=$with_tools_dir;
16161   if test "x$with_tools_dir" != x; then
16162     if test "x$TOOLCHAIN_PATH" = x; then
16163       TOOLCHAIN_PATH="$with_tools_dir"
16164     else
16165       TOOLCHAIN_PATH="$with_tools_dir:$TOOLCHAIN_PATH"
16166     fi
16167   fi
16168 
16169 
16170 fi
16171 
16172 
16173 
16174 # Check whether --with-toolchain-path was given.
16175 if test "${with_toolchain_path+set}" = set; then :
16176   withval=$with_toolchain_path;
16177   if test "x$with_toolchain_path" != x; then
16178     if test "x$TOOLCHAIN_PATH" = x; then
16179       TOOLCHAIN_PATH="$with_toolchain_path"
16180     else
16181       TOOLCHAIN_PATH="$with_toolchain_path:$TOOLCHAIN_PATH"
16182     fi
16183   fi
16184 
16185 
16186 fi
16187 
16188 
16189 
16190 # Check whether --with-extra-path was given.
16191 if test "${with_extra_path+set}" = set; then :
16192   withval=$with_extra_path;
16193   if test "x$with_extra_path" != x; then
16194     if test "x$EXTRA_PATH" = x; then
16195       EXTRA_PATH="$with_extra_path"
16196     else
16197       EXTRA_PATH="$with_extra_path:$EXTRA_PATH"
16198     fi
16199   fi
16200 
16201 
16202 fi
16203 
16204 
16205   if test "x$OPENJDK_BUILD_OS" = "xmacosx"; then
16206     # If a devkit has been supplied, find xcodebuild in the toolchain_path.
16207     # If not, detect if Xcode is installed by running xcodebuild -version
16208     # if no Xcode installed, xcodebuild exits with 1
16209     # if Xcode is installed, even if xcode-select is misconfigured, then it exits with 0
16210     if test "x$DEVKIT_ROOT" != x || /usr/bin/xcodebuild -version >/dev/null 2>&1; then
16211       # We need to use xcodebuild in the toolchain dir provided by the user, this will
16212       # fall back on the stub binary in /usr/bin/xcodebuild
16213       # Extract the first word of "xcodebuild", so it can be a program name with args.
16214 set dummy xcodebuild; ac_word=$2
16215 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
16216 $as_echo_n "checking for $ac_word... " >&6; }
16217 if ${ac_cv_path_XCODEBUILD+:} false; then :
16218   $as_echo_n "(cached) " >&6
16219 else
16220   case $XCODEBUILD in
16221   [\\/]* | ?:[\\/]*)
16222   ac_cv_path_XCODEBUILD="$XCODEBUILD" # Let the user override the test with a path.
16223   ;;
16224   *)
16225   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
16226 for as_dir in $TOOLCHAIN_PATH
16227 do
16228   IFS=$as_save_IFS
16229   test -z "$as_dir" && as_dir=.
16230     for ac_exec_ext in '' $ac_executable_extensions; do
16231   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
16232     ac_cv_path_XCODEBUILD="$as_dir/$ac_word$ac_exec_ext"
16233     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
16234     break 2
16235   fi
16236 done
16237   done
16238 IFS=$as_save_IFS
16239 
16240   test -z "$ac_cv_path_XCODEBUILD" && ac_cv_path_XCODEBUILD="/usr/bin/xcodebuild"
16241   ;;
16242 esac
16243 fi
16244 XCODEBUILD=$ac_cv_path_XCODEBUILD
16245 if test -n "$XCODEBUILD"; then
16246   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XCODEBUILD" >&5
16247 $as_echo "$XCODEBUILD" >&6; }
16248 else
16249   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
16250 $as_echo "no" >&6; }
16251 fi
16252 
16253 
16254     else
16255       # this should result in SYSROOT being empty, unless --with-sysroot is provided
16256       # when only the command line tools are installed there are no SDKs, so headers
16257       # are copied into the system frameworks
16258       XCODEBUILD=
16259 
16260     fi
16261 
16262     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for sdk name" >&5
16263 $as_echo_n "checking for sdk name... " >&6; }
16264 
16265 # Check whether --with-sdk-name was given.
16266 if test "${with_sdk_name+set}" = set; then :
16267   withval=$with_sdk_name; SDKNAME=$with_sdk_name
16268 
16269 fi
16270 
16271     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SDKNAME" >&5
16272 $as_echo "$SDKNAME" >&6; }
16273 
16274     # if toolchain path is specified then don't rely on system headers, they may not compile
16275     HAVE_SYSTEM_FRAMEWORK_HEADERS=0
16276     test -z "$TOOLCHAIN_PATH" && \
16277       HAVE_SYSTEM_FRAMEWORK_HEADERS=`test ! -f /System/Library/Frameworks/Foundation.framework/Headers/Foundation.h; echo $?`
16278 
16279     if test -z "$SYSROOT"; then
16280       if test -n "$XCODEBUILD"; then
16281         # if we don't have system headers, use default SDK name (last resort)
16282         if test -z "$SDKNAME" -a $HAVE_SYSTEM_FRAMEWORK_HEADERS -eq 0; then
16283           SDKNAME=${SDKNAME:-macosx}
16284         fi
16285 
16286         if test -n "$SDKNAME"; then
16287           # Call xcodebuild to determine SYSROOT
16288           SYSROOT=`"$XCODEBUILD" -sdk $SDKNAME -version | grep '^Path: ' | sed 's/Path: //'`
16289         fi
16290       else
16291         if test $HAVE_SYSTEM_FRAMEWORK_HEADERS -eq 0; then
16292           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
16293         fi
16294       fi
16295     else
16296       # warn user if --with-sdk-name was also set
16297       if test -n "$with_sdk_name"; then
16298         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Both SYSROOT and --with-sdk-name are set, only SYSROOT will be used" >&5
16299 $as_echo "$as_me: WARNING: Both SYSROOT and --with-sdk-name are set, only SYSROOT will be used" >&2;}
16300       fi
16301     fi
16302 
16303     if test $HAVE_SYSTEM_FRAMEWORK_HEADERS -eq 0 -a -z "$SYSROOT"; then
16304       # If no system framework headers, then SYSROOT must be set, or we won't build
16305       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
16306     fi
16307 
16308     # Perform a basic sanity test
16309     if test ! -f "$SYSROOT/System/Library/Frameworks/Foundation.framework/Headers/Foundation.h"; then
16310       if test -z "$SYSROOT"; then
16311         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
16312       else
16313         as_fn_error $? "Invalid SDK or SYSROOT path, dependent framework headers not found" "$LINENO" 5
16314       fi
16315     fi
16316 
16317     # set SDKROOT too, Xcode tools will pick it up
16318     SDKROOT=$SYSROOT
16319 
16320   fi
16321 
16322   # Prepend the extra path to the global path
16323 
16324   if test "x$EXTRA_PATH" != x; then
16325     if test "x$PATH" = x; then
16326       PATH="$EXTRA_PATH"
16327     else
16328       PATH="$EXTRA_PATH:$PATH"
16329     fi
16330   fi
16331 
16332 
16333   if test "x$OPENJDK_BUILD_OS" = "xsolaris"; then
16334     # Add extra search paths on solaris for utilities like ar and as etc...
16335     PATH="$PATH:/usr/ccs/bin:/usr/sfw/bin:/opt/csw/bin"
16336   fi
16337 
16338   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for sysroot" >&5
16339 $as_echo_n "checking for sysroot... " >&6; }
16340   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SYSROOT" >&5
16341 $as_echo "$SYSROOT" >&6; }
16342   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for toolchain path" >&5
16343 $as_echo_n "checking for toolchain path... " >&6; }
16344   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOOLCHAIN_PATH" >&5
16345 $as_echo "$TOOLCHAIN_PATH" >&6; }
16346   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for extra path" >&5
16347 $as_echo_n "checking for extra path... " >&6; }
16348   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXTRA_PATH" >&5
16349 $as_echo "$EXTRA_PATH" >&6; }
16350 
16351 
16352 # To properly create a configuration name, we need to have the OpenJDK target
16353 # and options (variants and debug level) parsed.
16354 
16355 
16356 
16357 # Check whether --with-conf-name was given.
16358 if test "${with_conf_name+set}" = set; then :
16359   withval=$with_conf_name;  CONF_NAME=${with_conf_name}
16360 fi
16361 
16362 
16363   # Test from where we are running configure, in or outside of src root.
16364   { $as_echo "$as_me:${as_lineno-$LINENO}: checking where to store configuration" >&5
16365 $as_echo_n "checking where to store configuration... " >&6; }
16366   if test "x$CURDIR" = "x$SRC_ROOT" || test "x$CURDIR" = "x$SRC_ROOT/common" \
16367       || test "x$CURDIR" = "x$SRC_ROOT/common/autoconf" \
16368       || test "x$CURDIR" = "x$SRC_ROOT/make" ; then
16369     # We are running configure from the src root.
16370     # Create a default ./build/target-variant-debuglevel output root.
16371     if test "x${CONF_NAME}" = x; then
16372       { $as_echo "$as_me:${as_lineno-$LINENO}: result: in default location" >&5
16373 $as_echo "in default location" >&6; }
16374       CONF_NAME="${OPENJDK_TARGET_OS}-${OPENJDK_TARGET_CPU}-${JDK_VARIANT}-${ANDED_JVM_VARIANTS}-${DEBUG_LEVEL}"
16375     else
16376       { $as_echo "$as_me:${as_lineno-$LINENO}: result: in build directory with custom name" >&5
16377 $as_echo "in build directory with custom name" >&6; }
16378     fi
16379     OUTPUT_ROOT="$SRC_ROOT/build/${CONF_NAME}"
16380     $MKDIR -p "$OUTPUT_ROOT"
16381     if test ! -d "$OUTPUT_ROOT"; then
16382       as_fn_error $? "Could not create build directory $OUTPUT_ROOT" "$LINENO" 5
16383     fi
16384   else
16385     # We are running configure from outside of the src dir.
16386     # Then use the current directory as output dir!
16387     # If configuration is situated in normal build directory, just use the build
16388     # directory name as configuration name, otherwise use the complete path.
16389     if test "x${CONF_NAME}" = x; then
16390       CONF_NAME=`$ECHO $CURDIR | $SED -e "s!^${SRC_ROOT}/build/!!"`
16391     fi
16392     OUTPUT_ROOT="$CURDIR"
16393     { $as_echo "$as_me:${as_lineno-$LINENO}: result: in current directory" >&5
16394 $as_echo "in current directory" >&6; }
16395 
16396     # WARNING: This might be a bad thing to do. You need to be sure you want to
16397     # have a configuration in this directory. Do some sanity checks!
16398 
16399     if test ! -e "$OUTPUT_ROOT/spec.gmk"; then
16400       # If we have a spec.gmk, we have run here before and we are OK. Otherwise, check for
16401       # other files
16402       files_present=`$LS $OUTPUT_ROOT`
16403       # Configure has already touched config.log and confdefs.h in the current dir when this check
16404       # is performed.
16405       filtered_files=`$ECHO "$files_present" \
16406           | $SED -e 's/config.log//g' \
16407               -e 's/configure.log//g' \
16408               -e 's/confdefs.h//g' \
16409               -e 's/ //g' \
16410           | $TR -d '\n'`
16411       if test "x$filtered_files" != x; then
16412         { $as_echo "$as_me:${as_lineno-$LINENO}: Current directory is $CURDIR." >&5
16413 $as_echo "$as_me: Current directory is $CURDIR." >&6;}
16414         { $as_echo "$as_me:${as_lineno-$LINENO}: Since this is not the source root, configure will output the configuration here" >&5
16415 $as_echo "$as_me: Since this is not the source root, configure will output the configuration here" >&6;}
16416         { $as_echo "$as_me:${as_lineno-$LINENO}: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&5
16417 $as_echo "$as_me: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&6;}
16418         { $as_echo "$as_me:${as_lineno-$LINENO}: However, this directory is not empty. This is not allowed, since it could" >&5
16419 $as_echo "$as_me: However, this directory is not empty. This is not allowed, since it could" >&6;}
16420         { $as_echo "$as_me:${as_lineno-$LINENO}: seriously mess up just about everything." >&5
16421 $as_echo "$as_me: seriously mess up just about everything." >&6;}
16422         { $as_echo "$as_me:${as_lineno-$LINENO}: Try 'cd $SRC_ROOT' and restart configure" >&5
16423 $as_echo "$as_me: Try 'cd $SRC_ROOT' and restart configure" >&6;}
16424         { $as_echo "$as_me:${as_lineno-$LINENO}: (or create a new empty directory and cd to it)." >&5
16425 $as_echo "$as_me: (or create a new empty directory and cd to it)." >&6;}
16426         as_fn_error $? "Will not continue creating configuration in $CURDIR" "$LINENO" 5
16427       fi
16428     fi
16429   fi
16430   { $as_echo "$as_me:${as_lineno-$LINENO}: checking what configuration name to use" >&5
16431 $as_echo_n "checking what configuration name to use... " >&6; }
16432   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CONF_NAME" >&5
16433 $as_echo "$CONF_NAME" >&6; }
16434 
16435 
16436   # Only process if variable expands to non-empty
16437 
16438   if test "x$OUTPUT_ROOT" != x; then
16439     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16440 
16441   # Input might be given as Windows format, start by converting to
16442   # unix format.
16443   path="$OUTPUT_ROOT"
16444   new_path=`$CYGPATH -u "$path"`
16445 
16446   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
16447   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
16448   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
16449   # "foo.exe" is OK but "foo" is an error.
16450   #
16451   # This test is therefore slightly more accurate than "test -f" to check for file precense.
16452   # It is also a way to make sure we got the proper file name for the real test later on.
16453   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
16454   if test "x$test_shortpath" = x; then
16455     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&5
16456 $as_echo "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&6;}
16457     as_fn_error $? "Cannot locate the the path of OUTPUT_ROOT" "$LINENO" 5
16458   fi
16459 
16460   # Call helper function which possibly converts this using DOS-style short mode.
16461   # If so, the updated path is stored in $new_path.
16462 
16463   input_path="$new_path"
16464   # Check if we need to convert this using DOS-style short mode. If the path
16465   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16466   # take no chances and rewrite it.
16467   # Note: m4 eats our [], so we need to use [ and ] instead.
16468   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
16469   if test "x$has_forbidden_chars" != x; then
16470     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16471     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
16472     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
16473     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
16474       # Going to short mode and back again did indeed matter. Since short mode is
16475       # case insensitive, let's make it lowercase to improve readability.
16476       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16477       # Now convert it back to Unix-style (cygpath)
16478       input_path=`$CYGPATH -u "$shortmode_path"`
16479       new_path="$input_path"
16480     fi
16481   fi
16482 
16483   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
16484   if test "x$test_cygdrive_prefix" = x; then
16485     # As a simple fix, exclude /usr/bin since it's not a real path.
16486     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
16487       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
16488       # a path prefixed by /cygdrive for fixpath to work.
16489       new_path="$CYGWIN_ROOT_PATH$input_path"
16490     fi
16491   fi
16492 
16493 
16494   if test "x$path" != "x$new_path"; then
16495     OUTPUT_ROOT="$new_path"
16496     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
16497 $as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
16498   fi
16499 
16500     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16501 
16502   path="$OUTPUT_ROOT"
16503   has_colon=`$ECHO $path | $GREP ^.:`
16504   new_path="$path"
16505   if test "x$has_colon" = x; then
16506     # Not in mixed or Windows style, start by that.
16507     new_path=`cmd //c echo $path`
16508   fi
16509 
16510 
16511   input_path="$new_path"
16512   # Check if we need to convert this using DOS-style short mode. If the path
16513   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16514   # take no chances and rewrite it.
16515   # Note: m4 eats our [], so we need to use [ and ] instead.
16516   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
16517   if test "x$has_forbidden_chars" != x; then
16518     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16519     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16520   fi
16521 
16522 
16523   windows_path="$new_path"
16524   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16525     unix_path=`$CYGPATH -u "$windows_path"`
16526     new_path="$unix_path"
16527   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16528     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16529     new_path="$unix_path"
16530   fi
16531 
16532   if test "x$path" != "x$new_path"; then
16533     OUTPUT_ROOT="$new_path"
16534     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
16535 $as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
16536   fi
16537 
16538   # Save the first 10 bytes of this path to the storage, so fixpath can work.
16539   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
16540 
16541     else
16542       # We're on a unix platform. Hooray! :)
16543       path="$OUTPUT_ROOT"
16544       has_space=`$ECHO "$path" | $GREP " "`
16545       if test "x$has_space" != x; then
16546         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&5
16547 $as_echo "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&6;}
16548         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
16549       fi
16550 
16551       # Use eval to expand a potential ~
16552       eval path="$path"
16553       if test ! -f "$path" && test ! -d "$path"; then
16554         as_fn_error $? "The path of OUTPUT_ROOT, which resolves as \"$path\", is not found." "$LINENO" 5
16555       fi
16556 
16557       OUTPUT_ROOT="`cd "$path"; $THEPWDCMD -L`"
16558     fi
16559   fi
16560 
16561 
16562   CONFIGURESUPPORT_OUTPUTDIR="$OUTPUT_ROOT/configure-support"
16563   $MKDIR -p "$CONFIGURESUPPORT_OUTPUTDIR"
16564 
16565   SPEC=$OUTPUT_ROOT/spec.gmk
16566 
16567   CONF_NAME=$CONF_NAME
16568 
16569   OUTPUT_ROOT=$OUTPUT_ROOT
16570 
16571 
16572 
16573   # The spec.gmk file contains all variables for the make system.
16574   ac_config_files="$ac_config_files $OUTPUT_ROOT/spec.gmk:$AUTOCONF_DIR/spec.gmk.in"
16575 
16576   # The hotspot-spec.gmk file contains legacy variables for the hotspot make system.
16577   ac_config_files="$ac_config_files $OUTPUT_ROOT/hotspot-spec.gmk:$AUTOCONF_DIR/hotspot-spec.gmk.in"
16578 
16579   # The bootcycle-spec.gmk file contains support for boot cycle builds.
16580   ac_config_files="$ac_config_files $OUTPUT_ROOT/bootcycle-spec.gmk:$AUTOCONF_DIR/bootcycle-spec.gmk.in"
16581 
16582   # The compare.sh is used to compare the build output to other builds.
16583   ac_config_files="$ac_config_files $OUTPUT_ROOT/compare.sh:$AUTOCONF_DIR/compare.sh.in"
16584 
16585   # The generated Makefile knows where the spec.gmk is and where the source is.
16586   # You can run make from the OUTPUT_ROOT, or from the top-level Makefile
16587   # which will look for generated configurations
16588   ac_config_files="$ac_config_files $OUTPUT_ROOT/Makefile:$AUTOCONF_DIR/Makefile.in"
16589 
16590 
16591 
16592 # Must be done before we can call HELP_MSG_MISSING_DEPENDENCY.
16593 
16594   for ac_prog in apt-get yum port pkgutil pkgadd
16595 do
16596   # Extract the first word of "$ac_prog", so it can be a program name with args.
16597 set dummy $ac_prog; ac_word=$2
16598 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
16599 $as_echo_n "checking for $ac_word... " >&6; }
16600 if ${ac_cv_prog_PKGHANDLER+:} false; then :
16601   $as_echo_n "(cached) " >&6
16602 else
16603   if test -n "$PKGHANDLER"; then
16604   ac_cv_prog_PKGHANDLER="$PKGHANDLER" # Let the user override the test.
16605 else
16606 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
16607 for as_dir in $PATH
16608 do
16609   IFS=$as_save_IFS
16610   test -z "$as_dir" && as_dir=.
16611     for ac_exec_ext in '' $ac_executable_extensions; do
16612   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
16613     ac_cv_prog_PKGHANDLER="$ac_prog"
16614     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
16615     break 2
16616   fi
16617 done
16618   done
16619 IFS=$as_save_IFS
16620 
16621 fi
16622 fi
16623 PKGHANDLER=$ac_cv_prog_PKGHANDLER
16624 if test -n "$PKGHANDLER"; then
16625   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKGHANDLER" >&5
16626 $as_echo "$PKGHANDLER" >&6; }
16627 else
16628   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
16629 $as_echo "no" >&6; }
16630 fi
16631 
16632 
16633   test -n "$PKGHANDLER" && break
16634 done
16635 
16636 
16637 
16638 # Setup tools that requires more complex handling, or that is not needed by the configure script.
16639 
16640 
16641 
16642   # Publish this variable in the help.
16643 
16644 
16645   if [ -z "${MAKE+x}" ]; then
16646     # The variable is not set by user, try to locate tool using the code snippet
16647 
16648     # Try our hardest to locate a correct version of GNU make
16649     for ac_prog in gmake
16650 do
16651   # Extract the first word of "$ac_prog", so it can be a program name with args.
16652 set dummy $ac_prog; ac_word=$2
16653 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
16654 $as_echo_n "checking for $ac_word... " >&6; }
16655 if ${ac_cv_path_CHECK_GMAKE+:} false; then :
16656   $as_echo_n "(cached) " >&6
16657 else
16658   case $CHECK_GMAKE in
16659   [\\/]* | ?:[\\/]*)
16660   ac_cv_path_CHECK_GMAKE="$CHECK_GMAKE" # Let the user override the test with a path.
16661   ;;
16662   *)
16663   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
16664 for as_dir in $PATH
16665 do
16666   IFS=$as_save_IFS
16667   test -z "$as_dir" && as_dir=.
16668     for ac_exec_ext in '' $ac_executable_extensions; do
16669   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
16670     ac_cv_path_CHECK_GMAKE="$as_dir/$ac_word$ac_exec_ext"
16671     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
16672     break 2
16673   fi
16674 done
16675   done
16676 IFS=$as_save_IFS
16677 
16678   ;;
16679 esac
16680 fi
16681 CHECK_GMAKE=$ac_cv_path_CHECK_GMAKE
16682 if test -n "$CHECK_GMAKE"; then
16683   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_GMAKE" >&5
16684 $as_echo "$CHECK_GMAKE" >&6; }
16685 else
16686   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
16687 $as_echo "no" >&6; }
16688 fi
16689 
16690 
16691   test -n "$CHECK_GMAKE" && break
16692 done
16693 
16694 
16695   MAKE_CANDIDATE=""$CHECK_GMAKE""
16696   DESCRIPTION="gmake in PATH"
16697 
16698   # On Cygwin, we require a newer version of make than on other platforms
16699   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16700     MAKE_VERSION_EXPR="-e 4\."
16701     MAKE_REQUIRED_VERSION="4.0"
16702    else
16703     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
16704     MAKE_REQUIRED_VERSION="3.81"
16705   fi
16706 
16707   if test "x$MAKE_CANDIDATE" != x; then
16708     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
16709 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
16710     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
16711     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
16712     if test "x$IS_GNU_MAKE" = x; then
16713       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
16714 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
16715     else
16716       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
16717       if test "x$IS_MODERN_MAKE" = x; then
16718         { $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
16719 $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;}
16720       else
16721         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
16722           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16723             MAKE_EXPECTED_ENV='cygwin'
16724           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16725             MAKE_EXPECTED_ENV='msys'
16726           else
16727             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
16728           fi
16729           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
16730           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
16731         else
16732           # Not relevant for non-Windows
16733           IS_MAKE_CORRECT_ENV=true
16734         fi
16735         if test "x$IS_MAKE_CORRECT_ENV" = x; then
16736           { $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
16737 $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;}
16738         else
16739           FOUND_MAKE=$MAKE_CANDIDATE
16740 
16741   # Only process if variable expands to non-empty
16742 
16743   if test "x$FOUND_MAKE" != x; then
16744     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16745 
16746   # First separate the path from the arguments. This will split at the first
16747   # space.
16748   complete="$FOUND_MAKE"
16749   path="${complete%% *}"
16750   tmp="$complete EOL"
16751   arguments="${tmp#* }"
16752 
16753   # Input might be given as Windows format, start by converting to
16754   # unix format.
16755   new_path=`$CYGPATH -u "$path"`
16756 
16757   # Now try to locate executable using which
16758   new_path=`$WHICH "$new_path" 2> /dev/null`
16759   # bat and cmd files are not always considered executable in cygwin causing which
16760   # to not find them
16761   if test "x$new_path" = x \
16762       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16763       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16764     new_path=`$CYGPATH -u "$path"`
16765   fi
16766   if test "x$new_path" = x; then
16767     # Oops. Which didn't find the executable.
16768     # The splitting of arguments from the executable at a space might have been incorrect,
16769     # since paths with space are more likely in Windows. Give it another try with the whole
16770     # argument.
16771     path="$complete"
16772     arguments="EOL"
16773     new_path=`$CYGPATH -u "$path"`
16774     new_path=`$WHICH "$new_path" 2> /dev/null`
16775     # bat and cmd files are not always considered executable in cygwin causing which
16776     # to not find them
16777     if test "x$new_path" = x \
16778         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16779         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16780       new_path=`$CYGPATH -u "$path"`
16781     fi
16782     if test "x$new_path" = x; then
16783       # It's still not found. Now this is an unrecoverable error.
16784       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16785 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16786       has_space=`$ECHO "$complete" | $GREP " "`
16787       if test "x$has_space" != x; then
16788         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16789 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16790       fi
16791       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16792     fi
16793   fi
16794 
16795   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
16796   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
16797   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
16798   # "foo.exe" is OK but "foo" is an error.
16799   #
16800   # This test is therefore slightly more accurate than "test -f" to check for file presence.
16801   # It is also a way to make sure we got the proper file name for the real test later on.
16802   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
16803   if test "x$test_shortpath" = x; then
16804     # Short path failed, file does not exist as specified.
16805     # Try adding .exe or .cmd
16806     if test -f "${new_path}.exe"; then
16807       input_to_shortpath="${new_path}.exe"
16808     elif test -f "${new_path}.cmd"; then
16809       input_to_shortpath="${new_path}.cmd"
16810     else
16811       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
16812 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
16813       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
16814 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
16815       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16816     fi
16817   else
16818     input_to_shortpath="$new_path"
16819   fi
16820 
16821   # Call helper function which possibly converts this using DOS-style short mode.
16822   # If so, the updated path is stored in $new_path.
16823   new_path="$input_to_shortpath"
16824 
16825   input_path="$input_to_shortpath"
16826   # Check if we need to convert this using DOS-style short mode. If the path
16827   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16828   # take no chances and rewrite it.
16829   # Note: m4 eats our [], so we need to use [ and ] instead.
16830   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
16831   if test "x$has_forbidden_chars" != x; then
16832     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16833     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
16834     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
16835     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
16836       # Going to short mode and back again did indeed matter. Since short mode is
16837       # case insensitive, let's make it lowercase to improve readability.
16838       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16839       # Now convert it back to Unix-style (cygpath)
16840       input_path=`$CYGPATH -u "$shortmode_path"`
16841       new_path="$input_path"
16842     fi
16843   fi
16844 
16845   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
16846   if test "x$test_cygdrive_prefix" = x; then
16847     # As a simple fix, exclude /usr/bin since it's not a real path.
16848     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
16849       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
16850       # a path prefixed by /cygdrive for fixpath to work.
16851       new_path="$CYGWIN_ROOT_PATH$input_path"
16852     fi
16853   fi
16854 
16855   # remove trailing .exe if any
16856   new_path="${new_path/%.exe/}"
16857 
16858     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16859 
16860   # First separate the path from the arguments. This will split at the first
16861   # space.
16862   complete="$FOUND_MAKE"
16863   path="${complete%% *}"
16864   tmp="$complete EOL"
16865   arguments="${tmp#* }"
16866 
16867   # Input might be given as Windows format, start by converting to
16868   # unix format.
16869   new_path="$path"
16870 
16871   windows_path="$new_path"
16872   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16873     unix_path=`$CYGPATH -u "$windows_path"`
16874     new_path="$unix_path"
16875   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16876     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16877     new_path="$unix_path"
16878   fi
16879 
16880 
16881   # Now try to locate executable using which
16882   new_path=`$WHICH "$new_path" 2> /dev/null`
16883 
16884   if test "x$new_path" = x; then
16885     # Oops. Which didn't find the executable.
16886     # The splitting of arguments from the executable at a space might have been incorrect,
16887     # since paths with space are more likely in Windows. Give it another try with the whole
16888     # argument.
16889     path="$complete"
16890     arguments="EOL"
16891     new_path="$path"
16892 
16893   windows_path="$new_path"
16894   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16895     unix_path=`$CYGPATH -u "$windows_path"`
16896     new_path="$unix_path"
16897   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16898     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16899     new_path="$unix_path"
16900   fi
16901 
16902 
16903     new_path=`$WHICH "$new_path" 2> /dev/null`
16904     # bat and cmd files are not always considered executable in MSYS causing which
16905     # to not find them
16906     if test "x$new_path" = x \
16907         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16908         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16909       new_path="$path"
16910 
16911   windows_path="$new_path"
16912   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16913     unix_path=`$CYGPATH -u "$windows_path"`
16914     new_path="$unix_path"
16915   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16916     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16917     new_path="$unix_path"
16918   fi
16919 
16920     fi
16921 
16922     if test "x$new_path" = x; then
16923       # It's still not found. Now this is an unrecoverable error.
16924       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16925 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16926       has_space=`$ECHO "$complete" | $GREP " "`
16927       if test "x$has_space" != x; then
16928         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16929 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16930       fi
16931       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16932     fi
16933   fi
16934 
16935   # Now new_path has a complete unix path to the binary
16936   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
16937     # Keep paths in /bin as-is, but remove trailing .exe if any
16938     new_path="${new_path/%.exe/}"
16939     # Do not save /bin paths to all_fixpath_prefixes!
16940   else
16941     # Not in mixed or Windows style, start by that.
16942     new_path=`cmd //c echo $new_path`
16943 
16944   input_path="$new_path"
16945   # Check if we need to convert this using DOS-style short mode. If the path
16946   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16947   # take no chances and rewrite it.
16948   # Note: m4 eats our [], so we need to use [ and ] instead.
16949   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
16950   if test "x$has_forbidden_chars" != x; then
16951     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16952     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16953   fi
16954 
16955     # Output is in $new_path
16956 
16957   windows_path="$new_path"
16958   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16959     unix_path=`$CYGPATH -u "$windows_path"`
16960     new_path="$unix_path"
16961   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16962     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16963     new_path="$unix_path"
16964   fi
16965 
16966     # remove trailing .exe if any
16967     new_path="${new_path/%.exe/}"
16968 
16969     # Save the first 10 bytes of this path to the storage, so fixpath can work.
16970     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
16971   fi
16972 
16973     else
16974       # We're on a unix platform. Hooray! :)
16975       # First separate the path from the arguments. This will split at the first
16976       # space.
16977       complete="$FOUND_MAKE"
16978       path="${complete%% *}"
16979       tmp="$complete EOL"
16980       arguments="${tmp#* }"
16981 
16982       # Cannot rely on the command "which" here since it doesn't always work.
16983       is_absolute_path=`$ECHO "$path" | $GREP ^/`
16984       if test -z "$is_absolute_path"; then
16985         # Path to executable is not absolute. Find it.
16986         IFS_save="$IFS"
16987         IFS=:
16988         for p in $PATH; do
16989           if test -f "$p/$path" && test -x "$p/$path"; then
16990             new_path="$p/$path"
16991             break
16992           fi
16993         done
16994         IFS="$IFS_save"
16995       else
16996         # This is an absolute path, we can use it without further modifications.
16997         new_path="$path"
16998       fi
16999 
17000       if test "x$new_path" = x; then
17001         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17002 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17003         has_space=`$ECHO "$complete" | $GREP " "`
17004         if test "x$has_space" != x; then
17005           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
17006 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
17007         fi
17008         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17009       fi
17010     fi
17011 
17012     # Now join together the path and the arguments once again
17013     if test "x$arguments" != xEOL; then
17014       new_complete="$new_path ${arguments% *}"
17015     else
17016       new_complete="$new_path"
17017     fi
17018 
17019     if test "x$complete" != "x$new_complete"; then
17020       FOUND_MAKE="$new_complete"
17021       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
17022 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
17023     fi
17024   fi
17025 
17026         fi
17027       fi
17028     fi
17029   fi
17030 
17031 
17032     if test "x$FOUND_MAKE" = x; then
17033       for ac_prog in make
17034 do
17035   # Extract the first word of "$ac_prog", so it can be a program name with args.
17036 set dummy $ac_prog; ac_word=$2
17037 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17038 $as_echo_n "checking for $ac_word... " >&6; }
17039 if ${ac_cv_path_CHECK_MAKE+:} false; then :
17040   $as_echo_n "(cached) " >&6
17041 else
17042   case $CHECK_MAKE in
17043   [\\/]* | ?:[\\/]*)
17044   ac_cv_path_CHECK_MAKE="$CHECK_MAKE" # Let the user override the test with a path.
17045   ;;
17046   *)
17047   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17048 for as_dir in $PATH
17049 do
17050   IFS=$as_save_IFS
17051   test -z "$as_dir" && as_dir=.
17052     for ac_exec_ext in '' $ac_executable_extensions; do
17053   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17054     ac_cv_path_CHECK_MAKE="$as_dir/$ac_word$ac_exec_ext"
17055     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17056     break 2
17057   fi
17058 done
17059   done
17060 IFS=$as_save_IFS
17061 
17062   ;;
17063 esac
17064 fi
17065 CHECK_MAKE=$ac_cv_path_CHECK_MAKE
17066 if test -n "$CHECK_MAKE"; then
17067   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_MAKE" >&5
17068 $as_echo "$CHECK_MAKE" >&6; }
17069 else
17070   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17071 $as_echo "no" >&6; }
17072 fi
17073 
17074 
17075   test -n "$CHECK_MAKE" && break
17076 done
17077 
17078 
17079   MAKE_CANDIDATE=""$CHECK_MAKE""
17080   DESCRIPTION="make in PATH"
17081 
17082   # On Cygwin, we require a newer version of make than on other platforms
17083   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17084     MAKE_VERSION_EXPR="-e 4\."
17085     MAKE_REQUIRED_VERSION="4.0"
17086    else
17087     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
17088     MAKE_REQUIRED_VERSION="3.81"
17089   fi
17090 
17091   if test "x$MAKE_CANDIDATE" != x; then
17092     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
17093 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
17094     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
17095     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
17096     if test "x$IS_GNU_MAKE" = x; then
17097       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
17098 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
17099     else
17100       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
17101       if test "x$IS_MODERN_MAKE" = x; then
17102         { $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
17103 $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;}
17104       else
17105         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
17106           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17107             MAKE_EXPECTED_ENV='cygwin'
17108           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17109             MAKE_EXPECTED_ENV='msys'
17110           else
17111             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
17112           fi
17113           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
17114           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
17115         else
17116           # Not relevant for non-Windows
17117           IS_MAKE_CORRECT_ENV=true
17118         fi
17119         if test "x$IS_MAKE_CORRECT_ENV" = x; then
17120           { $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
17121 $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;}
17122         else
17123           FOUND_MAKE=$MAKE_CANDIDATE
17124 
17125   # Only process if variable expands to non-empty
17126 
17127   if test "x$FOUND_MAKE" != x; then
17128     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17129 
17130   # First separate the path from the arguments. This will split at the first
17131   # space.
17132   complete="$FOUND_MAKE"
17133   path="${complete%% *}"
17134   tmp="$complete EOL"
17135   arguments="${tmp#* }"
17136 
17137   # Input might be given as Windows format, start by converting to
17138   # unix format.
17139   new_path=`$CYGPATH -u "$path"`
17140 
17141   # Now try to locate executable using which
17142   new_path=`$WHICH "$new_path" 2> /dev/null`
17143   # bat and cmd files are not always considered executable in cygwin causing which
17144   # to not find them
17145   if test "x$new_path" = x \
17146       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17147       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17148     new_path=`$CYGPATH -u "$path"`
17149   fi
17150   if test "x$new_path" = x; then
17151     # Oops. Which didn't find the executable.
17152     # The splitting of arguments from the executable at a space might have been incorrect,
17153     # since paths with space are more likely in Windows. Give it another try with the whole
17154     # argument.
17155     path="$complete"
17156     arguments="EOL"
17157     new_path=`$CYGPATH -u "$path"`
17158     new_path=`$WHICH "$new_path" 2> /dev/null`
17159     # bat and cmd files are not always considered executable in cygwin causing which
17160     # to not find them
17161     if test "x$new_path" = x \
17162         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17163         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17164       new_path=`$CYGPATH -u "$path"`
17165     fi
17166     if test "x$new_path" = x; then
17167       # It's still not found. Now this is an unrecoverable error.
17168       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17169 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17170       has_space=`$ECHO "$complete" | $GREP " "`
17171       if test "x$has_space" != x; then
17172         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
17173 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
17174       fi
17175       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17176     fi
17177   fi
17178 
17179   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
17180   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
17181   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
17182   # "foo.exe" is OK but "foo" is an error.
17183   #
17184   # This test is therefore slightly more accurate than "test -f" to check for file presence.
17185   # It is also a way to make sure we got the proper file name for the real test later on.
17186   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
17187   if test "x$test_shortpath" = x; then
17188     # Short path failed, file does not exist as specified.
17189     # Try adding .exe or .cmd
17190     if test -f "${new_path}.exe"; then
17191       input_to_shortpath="${new_path}.exe"
17192     elif test -f "${new_path}.cmd"; then
17193       input_to_shortpath="${new_path}.cmd"
17194     else
17195       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
17196 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
17197       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
17198 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
17199       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17200     fi
17201   else
17202     input_to_shortpath="$new_path"
17203   fi
17204 
17205   # Call helper function which possibly converts this using DOS-style short mode.
17206   # If so, the updated path is stored in $new_path.
17207   new_path="$input_to_shortpath"
17208 
17209   input_path="$input_to_shortpath"
17210   # Check if we need to convert this using DOS-style short mode. If the path
17211   # contains just simple characters, use it. Otherwise (spaces, weird characters),
17212   # take no chances and rewrite it.
17213   # Note: m4 eats our [], so we need to use [ and ] instead.
17214   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
17215   if test "x$has_forbidden_chars" != x; then
17216     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
17217     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
17218     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
17219     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
17220       # Going to short mode and back again did indeed matter. Since short mode is
17221       # case insensitive, let's make it lowercase to improve readability.
17222       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
17223       # Now convert it back to Unix-style (cygpath)
17224       input_path=`$CYGPATH -u "$shortmode_path"`
17225       new_path="$input_path"
17226     fi
17227   fi
17228 
17229   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
17230   if test "x$test_cygdrive_prefix" = x; then
17231     # As a simple fix, exclude /usr/bin since it's not a real path.
17232     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
17233       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
17234       # a path prefixed by /cygdrive for fixpath to work.
17235       new_path="$CYGWIN_ROOT_PATH$input_path"
17236     fi
17237   fi
17238 
17239   # remove trailing .exe if any
17240   new_path="${new_path/%.exe/}"
17241 
17242     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17243 
17244   # First separate the path from the arguments. This will split at the first
17245   # space.
17246   complete="$FOUND_MAKE"
17247   path="${complete%% *}"
17248   tmp="$complete EOL"
17249   arguments="${tmp#* }"
17250 
17251   # Input might be given as Windows format, start by converting to
17252   # unix format.
17253   new_path="$path"
17254 
17255   windows_path="$new_path"
17256   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17257     unix_path=`$CYGPATH -u "$windows_path"`
17258     new_path="$unix_path"
17259   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17260     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17261     new_path="$unix_path"
17262   fi
17263 
17264 
17265   # Now try to locate executable using which
17266   new_path=`$WHICH "$new_path" 2> /dev/null`
17267 
17268   if test "x$new_path" = x; then
17269     # Oops. Which didn't find the executable.
17270     # The splitting of arguments from the executable at a space might have been incorrect,
17271     # since paths with space are more likely in Windows. Give it another try with the whole
17272     # argument.
17273     path="$complete"
17274     arguments="EOL"
17275     new_path="$path"
17276 
17277   windows_path="$new_path"
17278   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17279     unix_path=`$CYGPATH -u "$windows_path"`
17280     new_path="$unix_path"
17281   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17282     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17283     new_path="$unix_path"
17284   fi
17285 
17286 
17287     new_path=`$WHICH "$new_path" 2> /dev/null`
17288     # bat and cmd files are not always considered executable in MSYS causing which
17289     # to not find them
17290     if test "x$new_path" = x \
17291         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17292         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17293       new_path="$path"
17294 
17295   windows_path="$new_path"
17296   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17297     unix_path=`$CYGPATH -u "$windows_path"`
17298     new_path="$unix_path"
17299   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17300     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17301     new_path="$unix_path"
17302   fi
17303 
17304     fi
17305 
17306     if test "x$new_path" = x; then
17307       # It's still not found. Now this is an unrecoverable error.
17308       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17309 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17310       has_space=`$ECHO "$complete" | $GREP " "`
17311       if test "x$has_space" != x; then
17312         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
17313 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
17314       fi
17315       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17316     fi
17317   fi
17318 
17319   # Now new_path has a complete unix path to the binary
17320   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
17321     # Keep paths in /bin as-is, but remove trailing .exe if any
17322     new_path="${new_path/%.exe/}"
17323     # Do not save /bin paths to all_fixpath_prefixes!
17324   else
17325     # Not in mixed or Windows style, start by that.
17326     new_path=`cmd //c echo $new_path`
17327 
17328   input_path="$new_path"
17329   # Check if we need to convert this using DOS-style short mode. If the path
17330   # contains just simple characters, use it. Otherwise (spaces, weird characters),
17331   # take no chances and rewrite it.
17332   # Note: m4 eats our [], so we need to use [ and ] instead.
17333   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
17334   if test "x$has_forbidden_chars" != x; then
17335     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
17336     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
17337   fi
17338 
17339     # Output is in $new_path
17340 
17341   windows_path="$new_path"
17342   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17343     unix_path=`$CYGPATH -u "$windows_path"`
17344     new_path="$unix_path"
17345   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17346     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17347     new_path="$unix_path"
17348   fi
17349 
17350     # remove trailing .exe if any
17351     new_path="${new_path/%.exe/}"
17352 
17353     # Save the first 10 bytes of this path to the storage, so fixpath can work.
17354     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
17355   fi
17356 
17357     else
17358       # We're on a unix platform. Hooray! :)
17359       # First separate the path from the arguments. This will split at the first
17360       # space.
17361       complete="$FOUND_MAKE"
17362       path="${complete%% *}"
17363       tmp="$complete EOL"
17364       arguments="${tmp#* }"
17365 
17366       # Cannot rely on the command "which" here since it doesn't always work.
17367       is_absolute_path=`$ECHO "$path" | $GREP ^/`
17368       if test -z "$is_absolute_path"; then
17369         # Path to executable is not absolute. Find it.
17370         IFS_save="$IFS"
17371         IFS=:
17372         for p in $PATH; do
17373           if test -f "$p/$path" && test -x "$p/$path"; then
17374             new_path="$p/$path"
17375             break
17376           fi
17377         done
17378         IFS="$IFS_save"
17379       else
17380         # This is an absolute path, we can use it without further modifications.
17381         new_path="$path"
17382       fi
17383 
17384       if test "x$new_path" = x; then
17385         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17386 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17387         has_space=`$ECHO "$complete" | $GREP " "`
17388         if test "x$has_space" != x; then
17389           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
17390 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
17391         fi
17392         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17393       fi
17394     fi
17395 
17396     # Now join together the path and the arguments once again
17397     if test "x$arguments" != xEOL; then
17398       new_complete="$new_path ${arguments% *}"
17399     else
17400       new_complete="$new_path"
17401     fi
17402 
17403     if test "x$complete" != "x$new_complete"; then
17404       FOUND_MAKE="$new_complete"
17405       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
17406 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
17407     fi
17408   fi
17409 
17410         fi
17411       fi
17412     fi
17413   fi
17414 
17415     fi
17416 
17417     if test "x$FOUND_MAKE" = x; then
17418       if test "x$TOOLCHAIN_PATH" != x; then
17419         # We have a toolchain path, check that as well before giving up.
17420         OLD_PATH=$PATH
17421         PATH=$TOOLCHAIN_PATH:$PATH
17422         for ac_prog in gmake
17423 do
17424   # Extract the first word of "$ac_prog", so it can be a program name with args.
17425 set dummy $ac_prog; ac_word=$2
17426 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17427 $as_echo_n "checking for $ac_word... " >&6; }
17428 if ${ac_cv_path_CHECK_TOOLSDIR_GMAKE+:} false; then :
17429   $as_echo_n "(cached) " >&6
17430 else
17431   case $CHECK_TOOLSDIR_GMAKE in
17432   [\\/]* | ?:[\\/]*)
17433   ac_cv_path_CHECK_TOOLSDIR_GMAKE="$CHECK_TOOLSDIR_GMAKE" # Let the user override the test with a path.
17434   ;;
17435   *)
17436   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17437 for as_dir in $PATH
17438 do
17439   IFS=$as_save_IFS
17440   test -z "$as_dir" && as_dir=.
17441     for ac_exec_ext in '' $ac_executable_extensions; do
17442   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17443     ac_cv_path_CHECK_TOOLSDIR_GMAKE="$as_dir/$ac_word$ac_exec_ext"
17444     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17445     break 2
17446   fi
17447 done
17448   done
17449 IFS=$as_save_IFS
17450 
17451   ;;
17452 esac
17453 fi
17454 CHECK_TOOLSDIR_GMAKE=$ac_cv_path_CHECK_TOOLSDIR_GMAKE
17455 if test -n "$CHECK_TOOLSDIR_GMAKE"; then
17456   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_GMAKE" >&5
17457 $as_echo "$CHECK_TOOLSDIR_GMAKE" >&6; }
17458 else
17459   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17460 $as_echo "no" >&6; }
17461 fi
17462 
17463 
17464   test -n "$CHECK_TOOLSDIR_GMAKE" && break
17465 done
17466 
17467 
17468   MAKE_CANDIDATE=""$CHECK_TOOLSDIR_GMAKE""
17469   DESCRIPTION="gmake in tools-dir"
17470 
17471   # On Cygwin, we require a newer version of make than on other platforms
17472   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17473     MAKE_VERSION_EXPR="-e 4\."
17474     MAKE_REQUIRED_VERSION="4.0"
17475    else
17476     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
17477     MAKE_REQUIRED_VERSION="3.81"
17478   fi
17479 
17480   if test "x$MAKE_CANDIDATE" != x; then
17481     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
17482 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
17483     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
17484     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
17485     if test "x$IS_GNU_MAKE" = x; then
17486       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
17487 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
17488     else
17489       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
17490       if test "x$IS_MODERN_MAKE" = x; then
17491         { $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
17492 $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;}
17493       else
17494         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
17495           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17496             MAKE_EXPECTED_ENV='cygwin'
17497           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17498             MAKE_EXPECTED_ENV='msys'
17499           else
17500             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
17501           fi
17502           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
17503           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
17504         else
17505           # Not relevant for non-Windows
17506           IS_MAKE_CORRECT_ENV=true
17507         fi
17508         if test "x$IS_MAKE_CORRECT_ENV" = x; then
17509           { $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
17510 $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;}
17511         else
17512           FOUND_MAKE=$MAKE_CANDIDATE
17513 
17514   # Only process if variable expands to non-empty
17515 
17516   if test "x$FOUND_MAKE" != x; then
17517     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17518 
17519   # First separate the path from the arguments. This will split at the first
17520   # space.
17521   complete="$FOUND_MAKE"
17522   path="${complete%% *}"
17523   tmp="$complete EOL"
17524   arguments="${tmp#* }"
17525 
17526   # Input might be given as Windows format, start by converting to
17527   # unix format.
17528   new_path=`$CYGPATH -u "$path"`
17529 
17530   # Now try to locate executable using which
17531   new_path=`$WHICH "$new_path" 2> /dev/null`
17532   # bat and cmd files are not always considered executable in cygwin causing which
17533   # to not find them
17534   if test "x$new_path" = x \
17535       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17536       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17537     new_path=`$CYGPATH -u "$path"`
17538   fi
17539   if test "x$new_path" = x; then
17540     # Oops. Which didn't find the executable.
17541     # The splitting of arguments from the executable at a space might have been incorrect,
17542     # since paths with space are more likely in Windows. Give it another try with the whole
17543     # argument.
17544     path="$complete"
17545     arguments="EOL"
17546     new_path=`$CYGPATH -u "$path"`
17547     new_path=`$WHICH "$new_path" 2> /dev/null`
17548     # bat and cmd files are not always considered executable in cygwin causing which
17549     # to not find them
17550     if test "x$new_path" = x \
17551         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17552         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17553       new_path=`$CYGPATH -u "$path"`
17554     fi
17555     if test "x$new_path" = x; then
17556       # It's still not found. Now this is an unrecoverable error.
17557       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17558 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17559       has_space=`$ECHO "$complete" | $GREP " "`
17560       if test "x$has_space" != x; then
17561         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
17562 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
17563       fi
17564       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17565     fi
17566   fi
17567 
17568   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
17569   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
17570   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
17571   # "foo.exe" is OK but "foo" is an error.
17572   #
17573   # This test is therefore slightly more accurate than "test -f" to check for file presence.
17574   # It is also a way to make sure we got the proper file name for the real test later on.
17575   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
17576   if test "x$test_shortpath" = x; then
17577     # Short path failed, file does not exist as specified.
17578     # Try adding .exe or .cmd
17579     if test -f "${new_path}.exe"; then
17580       input_to_shortpath="${new_path}.exe"
17581     elif test -f "${new_path}.cmd"; then
17582       input_to_shortpath="${new_path}.cmd"
17583     else
17584       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
17585 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
17586       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
17587 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
17588       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17589     fi
17590   else
17591     input_to_shortpath="$new_path"
17592   fi
17593 
17594   # Call helper function which possibly converts this using DOS-style short mode.
17595   # If so, the updated path is stored in $new_path.
17596   new_path="$input_to_shortpath"
17597 
17598   input_path="$input_to_shortpath"
17599   # Check if we need to convert this using DOS-style short mode. If the path
17600   # contains just simple characters, use it. Otherwise (spaces, weird characters),
17601   # take no chances and rewrite it.
17602   # Note: m4 eats our [], so we need to use [ and ] instead.
17603   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
17604   if test "x$has_forbidden_chars" != x; then
17605     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
17606     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
17607     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
17608     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
17609       # Going to short mode and back again did indeed matter. Since short mode is
17610       # case insensitive, let's make it lowercase to improve readability.
17611       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
17612       # Now convert it back to Unix-style (cygpath)
17613       input_path=`$CYGPATH -u "$shortmode_path"`
17614       new_path="$input_path"
17615     fi
17616   fi
17617 
17618   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
17619   if test "x$test_cygdrive_prefix" = x; then
17620     # As a simple fix, exclude /usr/bin since it's not a real path.
17621     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
17622       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
17623       # a path prefixed by /cygdrive for fixpath to work.
17624       new_path="$CYGWIN_ROOT_PATH$input_path"
17625     fi
17626   fi
17627 
17628   # remove trailing .exe if any
17629   new_path="${new_path/%.exe/}"
17630 
17631     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17632 
17633   # First separate the path from the arguments. This will split at the first
17634   # space.
17635   complete="$FOUND_MAKE"
17636   path="${complete%% *}"
17637   tmp="$complete EOL"
17638   arguments="${tmp#* }"
17639 
17640   # Input might be given as Windows format, start by converting to
17641   # unix format.
17642   new_path="$path"
17643 
17644   windows_path="$new_path"
17645   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17646     unix_path=`$CYGPATH -u "$windows_path"`
17647     new_path="$unix_path"
17648   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17649     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17650     new_path="$unix_path"
17651   fi
17652 
17653 
17654   # Now try to locate executable using which
17655   new_path=`$WHICH "$new_path" 2> /dev/null`
17656 
17657   if test "x$new_path" = x; then
17658     # Oops. Which didn't find the executable.
17659     # The splitting of arguments from the executable at a space might have been incorrect,
17660     # since paths with space are more likely in Windows. Give it another try with the whole
17661     # argument.
17662     path="$complete"
17663     arguments="EOL"
17664     new_path="$path"
17665 
17666   windows_path="$new_path"
17667   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17668     unix_path=`$CYGPATH -u "$windows_path"`
17669     new_path="$unix_path"
17670   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17671     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17672     new_path="$unix_path"
17673   fi
17674 
17675 
17676     new_path=`$WHICH "$new_path" 2> /dev/null`
17677     # bat and cmd files are not always considered executable in MSYS causing which
17678     # to not find them
17679     if test "x$new_path" = x \
17680         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17681         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17682       new_path="$path"
17683 
17684   windows_path="$new_path"
17685   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17686     unix_path=`$CYGPATH -u "$windows_path"`
17687     new_path="$unix_path"
17688   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17689     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17690     new_path="$unix_path"
17691   fi
17692 
17693     fi
17694 
17695     if test "x$new_path" = x; then
17696       # It's still not found. Now this is an unrecoverable error.
17697       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17698 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17699       has_space=`$ECHO "$complete" | $GREP " "`
17700       if test "x$has_space" != x; then
17701         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
17702 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
17703       fi
17704       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17705     fi
17706   fi
17707 
17708   # Now new_path has a complete unix path to the binary
17709   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
17710     # Keep paths in /bin as-is, but remove trailing .exe if any
17711     new_path="${new_path/%.exe/}"
17712     # Do not save /bin paths to all_fixpath_prefixes!
17713   else
17714     # Not in mixed or Windows style, start by that.
17715     new_path=`cmd //c echo $new_path`
17716 
17717   input_path="$new_path"
17718   # Check if we need to convert this using DOS-style short mode. If the path
17719   # contains just simple characters, use it. Otherwise (spaces, weird characters),
17720   # take no chances and rewrite it.
17721   # Note: m4 eats our [], so we need to use [ and ] instead.
17722   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
17723   if test "x$has_forbidden_chars" != x; then
17724     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
17725     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
17726   fi
17727 
17728     # Output is in $new_path
17729 
17730   windows_path="$new_path"
17731   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17732     unix_path=`$CYGPATH -u "$windows_path"`
17733     new_path="$unix_path"
17734   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17735     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17736     new_path="$unix_path"
17737   fi
17738 
17739     # remove trailing .exe if any
17740     new_path="${new_path/%.exe/}"
17741 
17742     # Save the first 10 bytes of this path to the storage, so fixpath can work.
17743     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
17744   fi
17745 
17746     else
17747       # We're on a unix platform. Hooray! :)
17748       # First separate the path from the arguments. This will split at the first
17749       # space.
17750       complete="$FOUND_MAKE"
17751       path="${complete%% *}"
17752       tmp="$complete EOL"
17753       arguments="${tmp#* }"
17754 
17755       # Cannot rely on the command "which" here since it doesn't always work.
17756       is_absolute_path=`$ECHO "$path" | $GREP ^/`
17757       if test -z "$is_absolute_path"; then
17758         # Path to executable is not absolute. Find it.
17759         IFS_save="$IFS"
17760         IFS=:
17761         for p in $PATH; do
17762           if test -f "$p/$path" && test -x "$p/$path"; then
17763             new_path="$p/$path"
17764             break
17765           fi
17766         done
17767         IFS="$IFS_save"
17768       else
17769         # This is an absolute path, we can use it without further modifications.
17770         new_path="$path"
17771       fi
17772 
17773       if test "x$new_path" = x; then
17774         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17775 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17776         has_space=`$ECHO "$complete" | $GREP " "`
17777         if test "x$has_space" != x; then
17778           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
17779 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
17780         fi
17781         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17782       fi
17783     fi
17784 
17785     # Now join together the path and the arguments once again
17786     if test "x$arguments" != xEOL; then
17787       new_complete="$new_path ${arguments% *}"
17788     else
17789       new_complete="$new_path"
17790     fi
17791 
17792     if test "x$complete" != "x$new_complete"; then
17793       FOUND_MAKE="$new_complete"
17794       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
17795 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
17796     fi
17797   fi
17798 
17799         fi
17800       fi
17801     fi
17802   fi
17803 
17804         if test "x$FOUND_MAKE" = x; then
17805           for ac_prog in make
17806 do
17807   # Extract the first word of "$ac_prog", so it can be a program name with args.
17808 set dummy $ac_prog; ac_word=$2
17809 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17810 $as_echo_n "checking for $ac_word... " >&6; }
17811 if ${ac_cv_path_CHECK_TOOLSDIR_MAKE+:} false; then :
17812   $as_echo_n "(cached) " >&6
17813 else
17814   case $CHECK_TOOLSDIR_MAKE in
17815   [\\/]* | ?:[\\/]*)
17816   ac_cv_path_CHECK_TOOLSDIR_MAKE="$CHECK_TOOLSDIR_MAKE" # Let the user override the test with a path.
17817   ;;
17818   *)
17819   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17820 for as_dir in $PATH
17821 do
17822   IFS=$as_save_IFS
17823   test -z "$as_dir" && as_dir=.
17824     for ac_exec_ext in '' $ac_executable_extensions; do
17825   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17826     ac_cv_path_CHECK_TOOLSDIR_MAKE="$as_dir/$ac_word$ac_exec_ext"
17827     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17828     break 2
17829   fi
17830 done
17831   done
17832 IFS=$as_save_IFS
17833 
17834   ;;
17835 esac
17836 fi
17837 CHECK_TOOLSDIR_MAKE=$ac_cv_path_CHECK_TOOLSDIR_MAKE
17838 if test -n "$CHECK_TOOLSDIR_MAKE"; then
17839   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_MAKE" >&5
17840 $as_echo "$CHECK_TOOLSDIR_MAKE" >&6; }
17841 else
17842   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17843 $as_echo "no" >&6; }
17844 fi
17845 
17846 
17847   test -n "$CHECK_TOOLSDIR_MAKE" && break
17848 done
17849 
17850 
17851   MAKE_CANDIDATE=""$CHECK_TOOLSDIR_MAKE""
17852   DESCRIPTION="make in tools-dir"
17853 
17854   # On Cygwin, we require a newer version of make than on other platforms
17855   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17856     MAKE_VERSION_EXPR="-e 4\."
17857     MAKE_REQUIRED_VERSION="4.0"
17858    else
17859     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
17860     MAKE_REQUIRED_VERSION="3.81"
17861   fi
17862 
17863   if test "x$MAKE_CANDIDATE" != x; then
17864     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
17865 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
17866     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
17867     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
17868     if test "x$IS_GNU_MAKE" = x; then
17869       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
17870 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
17871     else
17872       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
17873       if test "x$IS_MODERN_MAKE" = x; then
17874         { $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
17875 $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;}
17876       else
17877         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
17878           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17879             MAKE_EXPECTED_ENV='cygwin'
17880           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17881             MAKE_EXPECTED_ENV='msys'
17882           else
17883             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
17884           fi
17885           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
17886           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
17887         else
17888           # Not relevant for non-Windows
17889           IS_MAKE_CORRECT_ENV=true
17890         fi
17891         if test "x$IS_MAKE_CORRECT_ENV" = x; then
17892           { $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
17893 $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;}
17894         else
17895           FOUND_MAKE=$MAKE_CANDIDATE
17896 
17897   # Only process if variable expands to non-empty
17898 
17899   if test "x$FOUND_MAKE" != x; then
17900     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17901 
17902   # First separate the path from the arguments. This will split at the first
17903   # space.
17904   complete="$FOUND_MAKE"
17905   path="${complete%% *}"
17906   tmp="$complete EOL"
17907   arguments="${tmp#* }"
17908 
17909   # Input might be given as Windows format, start by converting to
17910   # unix format.
17911   new_path=`$CYGPATH -u "$path"`
17912 
17913   # Now try to locate executable using which
17914   new_path=`$WHICH "$new_path" 2> /dev/null`
17915   # bat and cmd files are not always considered executable in cygwin causing which
17916   # to not find them
17917   if test "x$new_path" = x \
17918       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17919       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17920     new_path=`$CYGPATH -u "$path"`
17921   fi
17922   if test "x$new_path" = x; then
17923     # Oops. Which didn't find the executable.
17924     # The splitting of arguments from the executable at a space might have been incorrect,
17925     # since paths with space are more likely in Windows. Give it another try with the whole
17926     # argument.
17927     path="$complete"
17928     arguments="EOL"
17929     new_path=`$CYGPATH -u "$path"`
17930     new_path=`$WHICH "$new_path" 2> /dev/null`
17931     # bat and cmd files are not always considered executable in cygwin causing which
17932     # to not find them
17933     if test "x$new_path" = x \
17934         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17935         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17936       new_path=`$CYGPATH -u "$path"`
17937     fi
17938     if test "x$new_path" = x; then
17939       # It's still not found. Now this is an unrecoverable error.
17940       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17941 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17942       has_space=`$ECHO "$complete" | $GREP " "`
17943       if test "x$has_space" != x; then
17944         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
17945 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
17946       fi
17947       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17948     fi
17949   fi
17950 
17951   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
17952   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
17953   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
17954   # "foo.exe" is OK but "foo" is an error.
17955   #
17956   # This test is therefore slightly more accurate than "test -f" to check for file presence.
17957   # It is also a way to make sure we got the proper file name for the real test later on.
17958   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
17959   if test "x$test_shortpath" = x; then
17960     # Short path failed, file does not exist as specified.
17961     # Try adding .exe or .cmd
17962     if test -f "${new_path}.exe"; then
17963       input_to_shortpath="${new_path}.exe"
17964     elif test -f "${new_path}.cmd"; then
17965       input_to_shortpath="${new_path}.cmd"
17966     else
17967       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
17968 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
17969       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
17970 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
17971       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17972     fi
17973   else
17974     input_to_shortpath="$new_path"
17975   fi
17976 
17977   # Call helper function which possibly converts this using DOS-style short mode.
17978   # If so, the updated path is stored in $new_path.
17979   new_path="$input_to_shortpath"
17980 
17981   input_path="$input_to_shortpath"
17982   # Check if we need to convert this using DOS-style short mode. If the path
17983   # contains just simple characters, use it. Otherwise (spaces, weird characters),
17984   # take no chances and rewrite it.
17985   # Note: m4 eats our [], so we need to use [ and ] instead.
17986   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
17987   if test "x$has_forbidden_chars" != x; then
17988     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
17989     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
17990     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
17991     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
17992       # Going to short mode and back again did indeed matter. Since short mode is
17993       # case insensitive, let's make it lowercase to improve readability.
17994       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
17995       # Now convert it back to Unix-style (cygpath)
17996       input_path=`$CYGPATH -u "$shortmode_path"`
17997       new_path="$input_path"
17998     fi
17999   fi
18000 
18001   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
18002   if test "x$test_cygdrive_prefix" = x; then
18003     # As a simple fix, exclude /usr/bin since it's not a real path.
18004     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
18005       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
18006       # a path prefixed by /cygdrive for fixpath to work.
18007       new_path="$CYGWIN_ROOT_PATH$input_path"
18008     fi
18009   fi
18010 
18011   # remove trailing .exe if any
18012   new_path="${new_path/%.exe/}"
18013 
18014     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18015 
18016   # First separate the path from the arguments. This will split at the first
18017   # space.
18018   complete="$FOUND_MAKE"
18019   path="${complete%% *}"
18020   tmp="$complete EOL"
18021   arguments="${tmp#* }"
18022 
18023   # Input might be given as Windows format, start by converting to
18024   # unix format.
18025   new_path="$path"
18026 
18027   windows_path="$new_path"
18028   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18029     unix_path=`$CYGPATH -u "$windows_path"`
18030     new_path="$unix_path"
18031   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18032     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18033     new_path="$unix_path"
18034   fi
18035 
18036 
18037   # Now try to locate executable using which
18038   new_path=`$WHICH "$new_path" 2> /dev/null`
18039 
18040   if test "x$new_path" = x; then
18041     # Oops. Which didn't find the executable.
18042     # The splitting of arguments from the executable at a space might have been incorrect,
18043     # since paths with space are more likely in Windows. Give it another try with the whole
18044     # argument.
18045     path="$complete"
18046     arguments="EOL"
18047     new_path="$path"
18048 
18049   windows_path="$new_path"
18050   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18051     unix_path=`$CYGPATH -u "$windows_path"`
18052     new_path="$unix_path"
18053   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18054     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18055     new_path="$unix_path"
18056   fi
18057 
18058 
18059     new_path=`$WHICH "$new_path" 2> /dev/null`
18060     # bat and cmd files are not always considered executable in MSYS causing which
18061     # to not find them
18062     if test "x$new_path" = x \
18063         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18064         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18065       new_path="$path"
18066 
18067   windows_path="$new_path"
18068   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18069     unix_path=`$CYGPATH -u "$windows_path"`
18070     new_path="$unix_path"
18071   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18072     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18073     new_path="$unix_path"
18074   fi
18075 
18076     fi
18077 
18078     if test "x$new_path" = x; then
18079       # It's still not found. Now this is an unrecoverable error.
18080       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18081 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18082       has_space=`$ECHO "$complete" | $GREP " "`
18083       if test "x$has_space" != x; then
18084         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
18085 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
18086       fi
18087       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18088     fi
18089   fi
18090 
18091   # Now new_path has a complete unix path to the binary
18092   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
18093     # Keep paths in /bin as-is, but remove trailing .exe if any
18094     new_path="${new_path/%.exe/}"
18095     # Do not save /bin paths to all_fixpath_prefixes!
18096   else
18097     # Not in mixed or Windows style, start by that.
18098     new_path=`cmd //c echo $new_path`
18099 
18100   input_path="$new_path"
18101   # Check if we need to convert this using DOS-style short mode. If the path
18102   # contains just simple characters, use it. Otherwise (spaces, weird characters),
18103   # take no chances and rewrite it.
18104   # Note: m4 eats our [], so we need to use [ and ] instead.
18105   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
18106   if test "x$has_forbidden_chars" != x; then
18107     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
18108     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
18109   fi
18110 
18111     # Output is in $new_path
18112 
18113   windows_path="$new_path"
18114   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18115     unix_path=`$CYGPATH -u "$windows_path"`
18116     new_path="$unix_path"
18117   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18118     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18119     new_path="$unix_path"
18120   fi
18121 
18122     # remove trailing .exe if any
18123     new_path="${new_path/%.exe/}"
18124 
18125     # Save the first 10 bytes of this path to the storage, so fixpath can work.
18126     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
18127   fi
18128 
18129     else
18130       # We're on a unix platform. Hooray! :)
18131       # First separate the path from the arguments. This will split at the first
18132       # space.
18133       complete="$FOUND_MAKE"
18134       path="${complete%% *}"
18135       tmp="$complete EOL"
18136       arguments="${tmp#* }"
18137 
18138       # Cannot rely on the command "which" here since it doesn't always work.
18139       is_absolute_path=`$ECHO "$path" | $GREP ^/`
18140       if test -z "$is_absolute_path"; then
18141         # Path to executable is not absolute. Find it.
18142         IFS_save="$IFS"
18143         IFS=:
18144         for p in $PATH; do
18145           if test -f "$p/$path" && test -x "$p/$path"; then
18146             new_path="$p/$path"
18147             break
18148           fi
18149         done
18150         IFS="$IFS_save"
18151       else
18152         # This is an absolute path, we can use it without further modifications.
18153         new_path="$path"
18154       fi
18155 
18156       if test "x$new_path" = x; then
18157         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18158 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18159         has_space=`$ECHO "$complete" | $GREP " "`
18160         if test "x$has_space" != x; then
18161           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
18162 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
18163         fi
18164         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18165       fi
18166     fi
18167 
18168     # Now join together the path and the arguments once again
18169     if test "x$arguments" != xEOL; then
18170       new_complete="$new_path ${arguments% *}"
18171     else
18172       new_complete="$new_path"
18173     fi
18174 
18175     if test "x$complete" != "x$new_complete"; then
18176       FOUND_MAKE="$new_complete"
18177       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
18178 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
18179     fi
18180   fi
18181 
18182         fi
18183       fi
18184     fi
18185   fi
18186 
18187         fi
18188         PATH=$OLD_PATH
18189       fi
18190     fi
18191 
18192     if test "x$FOUND_MAKE" = x; then
18193       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
18194     fi
18195 
18196   else
18197     # The variable is set, but is it from the command line or the environment?
18198 
18199     # Try to remove the string !MAKE! from our list.
18200     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MAKE!/}
18201     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18202       # If it failed, the variable was not from the command line. Ignore it,
18203       # but warn the user (except for BASH, which is always set by the calling BASH).
18204       if test "xMAKE" != xBASH; then
18205         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MAKE from the environment. Use command line variables instead." >&5
18206 $as_echo "$as_me: WARNING: Ignoring value of MAKE from the environment. Use command line variables instead." >&2;}
18207       fi
18208       # Try to locate tool using the code snippet
18209 
18210     # Try our hardest to locate a correct version of GNU make
18211     for ac_prog in gmake
18212 do
18213   # Extract the first word of "$ac_prog", so it can be a program name with args.
18214 set dummy $ac_prog; ac_word=$2
18215 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18216 $as_echo_n "checking for $ac_word... " >&6; }
18217 if ${ac_cv_path_CHECK_GMAKE+:} false; then :
18218   $as_echo_n "(cached) " >&6
18219 else
18220   case $CHECK_GMAKE in
18221   [\\/]* | ?:[\\/]*)
18222   ac_cv_path_CHECK_GMAKE="$CHECK_GMAKE" # Let the user override the test with a path.
18223   ;;
18224   *)
18225   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18226 for as_dir in $PATH
18227 do
18228   IFS=$as_save_IFS
18229   test -z "$as_dir" && as_dir=.
18230     for ac_exec_ext in '' $ac_executable_extensions; do
18231   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18232     ac_cv_path_CHECK_GMAKE="$as_dir/$ac_word$ac_exec_ext"
18233     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18234     break 2
18235   fi
18236 done
18237   done
18238 IFS=$as_save_IFS
18239 
18240   ;;
18241 esac
18242 fi
18243 CHECK_GMAKE=$ac_cv_path_CHECK_GMAKE
18244 if test -n "$CHECK_GMAKE"; then
18245   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_GMAKE" >&5
18246 $as_echo "$CHECK_GMAKE" >&6; }
18247 else
18248   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18249 $as_echo "no" >&6; }
18250 fi
18251 
18252 
18253   test -n "$CHECK_GMAKE" && break
18254 done
18255 
18256 
18257   MAKE_CANDIDATE=""$CHECK_GMAKE""
18258   DESCRIPTION="gmake in PATH"
18259 
18260   # On Cygwin, we require a newer version of make than on other platforms
18261   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18262     MAKE_VERSION_EXPR="-e 4\."
18263     MAKE_REQUIRED_VERSION="4.0"
18264    else
18265     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
18266     MAKE_REQUIRED_VERSION="3.81"
18267   fi
18268 
18269   if test "x$MAKE_CANDIDATE" != x; then
18270     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
18271 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
18272     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
18273     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
18274     if test "x$IS_GNU_MAKE" = x; then
18275       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
18276 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
18277     else
18278       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
18279       if test "x$IS_MODERN_MAKE" = x; then
18280         { $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
18281 $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;}
18282       else
18283         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
18284           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18285             MAKE_EXPECTED_ENV='cygwin'
18286           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18287             MAKE_EXPECTED_ENV='msys'
18288           else
18289             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
18290           fi
18291           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
18292           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
18293         else
18294           # Not relevant for non-Windows
18295           IS_MAKE_CORRECT_ENV=true
18296         fi
18297         if test "x$IS_MAKE_CORRECT_ENV" = x; then
18298           { $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
18299 $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;}
18300         else
18301           FOUND_MAKE=$MAKE_CANDIDATE
18302 
18303   # Only process if variable expands to non-empty
18304 
18305   if test "x$FOUND_MAKE" != x; then
18306     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18307 
18308   # First separate the path from the arguments. This will split at the first
18309   # space.
18310   complete="$FOUND_MAKE"
18311   path="${complete%% *}"
18312   tmp="$complete EOL"
18313   arguments="${tmp#* }"
18314 
18315   # Input might be given as Windows format, start by converting to
18316   # unix format.
18317   new_path=`$CYGPATH -u "$path"`
18318 
18319   # Now try to locate executable using which
18320   new_path=`$WHICH "$new_path" 2> /dev/null`
18321   # bat and cmd files are not always considered executable in cygwin causing which
18322   # to not find them
18323   if test "x$new_path" = x \
18324       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18325       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18326     new_path=`$CYGPATH -u "$path"`
18327   fi
18328   if test "x$new_path" = x; then
18329     # Oops. Which didn't find the executable.
18330     # The splitting of arguments from the executable at a space might have been incorrect,
18331     # since paths with space are more likely in Windows. Give it another try with the whole
18332     # argument.
18333     path="$complete"
18334     arguments="EOL"
18335     new_path=`$CYGPATH -u "$path"`
18336     new_path=`$WHICH "$new_path" 2> /dev/null`
18337     # bat and cmd files are not always considered executable in cygwin causing which
18338     # to not find them
18339     if test "x$new_path" = x \
18340         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18341         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18342       new_path=`$CYGPATH -u "$path"`
18343     fi
18344     if test "x$new_path" = x; then
18345       # It's still not found. Now this is an unrecoverable error.
18346       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18347 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18348       has_space=`$ECHO "$complete" | $GREP " "`
18349       if test "x$has_space" != x; then
18350         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
18351 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
18352       fi
18353       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18354     fi
18355   fi
18356 
18357   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
18358   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
18359   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
18360   # "foo.exe" is OK but "foo" is an error.
18361   #
18362   # This test is therefore slightly more accurate than "test -f" to check for file presence.
18363   # It is also a way to make sure we got the proper file name for the real test later on.
18364   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
18365   if test "x$test_shortpath" = x; then
18366     # Short path failed, file does not exist as specified.
18367     # Try adding .exe or .cmd
18368     if test -f "${new_path}.exe"; then
18369       input_to_shortpath="${new_path}.exe"
18370     elif test -f "${new_path}.cmd"; then
18371       input_to_shortpath="${new_path}.cmd"
18372     else
18373       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
18374 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
18375       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
18376 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
18377       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18378     fi
18379   else
18380     input_to_shortpath="$new_path"
18381   fi
18382 
18383   # Call helper function which possibly converts this using DOS-style short mode.
18384   # If so, the updated path is stored in $new_path.
18385   new_path="$input_to_shortpath"
18386 
18387   input_path="$input_to_shortpath"
18388   # Check if we need to convert this using DOS-style short mode. If the path
18389   # contains just simple characters, use it. Otherwise (spaces, weird characters),
18390   # take no chances and rewrite it.
18391   # Note: m4 eats our [], so we need to use [ and ] instead.
18392   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
18393   if test "x$has_forbidden_chars" != x; then
18394     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
18395     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
18396     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
18397     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
18398       # Going to short mode and back again did indeed matter. Since short mode is
18399       # case insensitive, let's make it lowercase to improve readability.
18400       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
18401       # Now convert it back to Unix-style (cygpath)
18402       input_path=`$CYGPATH -u "$shortmode_path"`
18403       new_path="$input_path"
18404     fi
18405   fi
18406 
18407   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
18408   if test "x$test_cygdrive_prefix" = x; then
18409     # As a simple fix, exclude /usr/bin since it's not a real path.
18410     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
18411       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
18412       # a path prefixed by /cygdrive for fixpath to work.
18413       new_path="$CYGWIN_ROOT_PATH$input_path"
18414     fi
18415   fi
18416 
18417   # remove trailing .exe if any
18418   new_path="${new_path/%.exe/}"
18419 
18420     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18421 
18422   # First separate the path from the arguments. This will split at the first
18423   # space.
18424   complete="$FOUND_MAKE"
18425   path="${complete%% *}"
18426   tmp="$complete EOL"
18427   arguments="${tmp#* }"
18428 
18429   # Input might be given as Windows format, start by converting to
18430   # unix format.
18431   new_path="$path"
18432 
18433   windows_path="$new_path"
18434   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18435     unix_path=`$CYGPATH -u "$windows_path"`
18436     new_path="$unix_path"
18437   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18438     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18439     new_path="$unix_path"
18440   fi
18441 
18442 
18443   # Now try to locate executable using which
18444   new_path=`$WHICH "$new_path" 2> /dev/null`
18445 
18446   if test "x$new_path" = x; then
18447     # Oops. Which didn't find the executable.
18448     # The splitting of arguments from the executable at a space might have been incorrect,
18449     # since paths with space are more likely in Windows. Give it another try with the whole
18450     # argument.
18451     path="$complete"
18452     arguments="EOL"
18453     new_path="$path"
18454 
18455   windows_path="$new_path"
18456   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18457     unix_path=`$CYGPATH -u "$windows_path"`
18458     new_path="$unix_path"
18459   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18460     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18461     new_path="$unix_path"
18462   fi
18463 
18464 
18465     new_path=`$WHICH "$new_path" 2> /dev/null`
18466     # bat and cmd files are not always considered executable in MSYS causing which
18467     # to not find them
18468     if test "x$new_path" = x \
18469         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18470         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18471       new_path="$path"
18472 
18473   windows_path="$new_path"
18474   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18475     unix_path=`$CYGPATH -u "$windows_path"`
18476     new_path="$unix_path"
18477   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18478     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18479     new_path="$unix_path"
18480   fi
18481 
18482     fi
18483 
18484     if test "x$new_path" = x; then
18485       # It's still not found. Now this is an unrecoverable error.
18486       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18487 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18488       has_space=`$ECHO "$complete" | $GREP " "`
18489       if test "x$has_space" != x; then
18490         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
18491 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
18492       fi
18493       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18494     fi
18495   fi
18496 
18497   # Now new_path has a complete unix path to the binary
18498   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
18499     # Keep paths in /bin as-is, but remove trailing .exe if any
18500     new_path="${new_path/%.exe/}"
18501     # Do not save /bin paths to all_fixpath_prefixes!
18502   else
18503     # Not in mixed or Windows style, start by that.
18504     new_path=`cmd //c echo $new_path`
18505 
18506   input_path="$new_path"
18507   # Check if we need to convert this using DOS-style short mode. If the path
18508   # contains just simple characters, use it. Otherwise (spaces, weird characters),
18509   # take no chances and rewrite it.
18510   # Note: m4 eats our [], so we need to use [ and ] instead.
18511   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
18512   if test "x$has_forbidden_chars" != x; then
18513     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
18514     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
18515   fi
18516 
18517     # Output is in $new_path
18518 
18519   windows_path="$new_path"
18520   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18521     unix_path=`$CYGPATH -u "$windows_path"`
18522     new_path="$unix_path"
18523   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18524     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18525     new_path="$unix_path"
18526   fi
18527 
18528     # remove trailing .exe if any
18529     new_path="${new_path/%.exe/}"
18530 
18531     # Save the first 10 bytes of this path to the storage, so fixpath can work.
18532     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
18533   fi
18534 
18535     else
18536       # We're on a unix platform. Hooray! :)
18537       # First separate the path from the arguments. This will split at the first
18538       # space.
18539       complete="$FOUND_MAKE"
18540       path="${complete%% *}"
18541       tmp="$complete EOL"
18542       arguments="${tmp#* }"
18543 
18544       # Cannot rely on the command "which" here since it doesn't always work.
18545       is_absolute_path=`$ECHO "$path" | $GREP ^/`
18546       if test -z "$is_absolute_path"; then
18547         # Path to executable is not absolute. Find it.
18548         IFS_save="$IFS"
18549         IFS=:
18550         for p in $PATH; do
18551           if test -f "$p/$path" && test -x "$p/$path"; then
18552             new_path="$p/$path"
18553             break
18554           fi
18555         done
18556         IFS="$IFS_save"
18557       else
18558         # This is an absolute path, we can use it without further modifications.
18559         new_path="$path"
18560       fi
18561 
18562       if test "x$new_path" = x; then
18563         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18564 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18565         has_space=`$ECHO "$complete" | $GREP " "`
18566         if test "x$has_space" != x; then
18567           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
18568 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
18569         fi
18570         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18571       fi
18572     fi
18573 
18574     # Now join together the path and the arguments once again
18575     if test "x$arguments" != xEOL; then
18576       new_complete="$new_path ${arguments% *}"
18577     else
18578       new_complete="$new_path"
18579     fi
18580 
18581     if test "x$complete" != "x$new_complete"; then
18582       FOUND_MAKE="$new_complete"
18583       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
18584 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
18585     fi
18586   fi
18587 
18588         fi
18589       fi
18590     fi
18591   fi
18592 
18593 
18594     if test "x$FOUND_MAKE" = x; then
18595       for ac_prog in make
18596 do
18597   # Extract the first word of "$ac_prog", so it can be a program name with args.
18598 set dummy $ac_prog; ac_word=$2
18599 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18600 $as_echo_n "checking for $ac_word... " >&6; }
18601 if ${ac_cv_path_CHECK_MAKE+:} false; then :
18602   $as_echo_n "(cached) " >&6
18603 else
18604   case $CHECK_MAKE in
18605   [\\/]* | ?:[\\/]*)
18606   ac_cv_path_CHECK_MAKE="$CHECK_MAKE" # Let the user override the test with a path.
18607   ;;
18608   *)
18609   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18610 for as_dir in $PATH
18611 do
18612   IFS=$as_save_IFS
18613   test -z "$as_dir" && as_dir=.
18614     for ac_exec_ext in '' $ac_executable_extensions; do
18615   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18616     ac_cv_path_CHECK_MAKE="$as_dir/$ac_word$ac_exec_ext"
18617     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18618     break 2
18619   fi
18620 done
18621   done
18622 IFS=$as_save_IFS
18623 
18624   ;;
18625 esac
18626 fi
18627 CHECK_MAKE=$ac_cv_path_CHECK_MAKE
18628 if test -n "$CHECK_MAKE"; then
18629   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_MAKE" >&5
18630 $as_echo "$CHECK_MAKE" >&6; }
18631 else
18632   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18633 $as_echo "no" >&6; }
18634 fi
18635 
18636 
18637   test -n "$CHECK_MAKE" && break
18638 done
18639 
18640 
18641   MAKE_CANDIDATE=""$CHECK_MAKE""
18642   DESCRIPTION="make in PATH"
18643 
18644   # On Cygwin, we require a newer version of make than on other platforms
18645   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18646     MAKE_VERSION_EXPR="-e 4\."
18647     MAKE_REQUIRED_VERSION="4.0"
18648    else
18649     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
18650     MAKE_REQUIRED_VERSION="3.81"
18651   fi
18652 
18653   if test "x$MAKE_CANDIDATE" != x; then
18654     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
18655 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
18656     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
18657     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
18658     if test "x$IS_GNU_MAKE" = x; then
18659       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
18660 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
18661     else
18662       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
18663       if test "x$IS_MODERN_MAKE" = x; then
18664         { $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
18665 $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;}
18666       else
18667         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
18668           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18669             MAKE_EXPECTED_ENV='cygwin'
18670           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18671             MAKE_EXPECTED_ENV='msys'
18672           else
18673             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
18674           fi
18675           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
18676           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
18677         else
18678           # Not relevant for non-Windows
18679           IS_MAKE_CORRECT_ENV=true
18680         fi
18681         if test "x$IS_MAKE_CORRECT_ENV" = x; then
18682           { $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
18683 $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;}
18684         else
18685           FOUND_MAKE=$MAKE_CANDIDATE
18686 
18687   # Only process if variable expands to non-empty
18688 
18689   if test "x$FOUND_MAKE" != x; then
18690     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18691 
18692   # First separate the path from the arguments. This will split at the first
18693   # space.
18694   complete="$FOUND_MAKE"
18695   path="${complete%% *}"
18696   tmp="$complete EOL"
18697   arguments="${tmp#* }"
18698 
18699   # Input might be given as Windows format, start by converting to
18700   # unix format.
18701   new_path=`$CYGPATH -u "$path"`
18702 
18703   # Now try to locate executable using which
18704   new_path=`$WHICH "$new_path" 2> /dev/null`
18705   # bat and cmd files are not always considered executable in cygwin causing which
18706   # to not find them
18707   if test "x$new_path" = x \
18708       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18709       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18710     new_path=`$CYGPATH -u "$path"`
18711   fi
18712   if test "x$new_path" = x; then
18713     # Oops. Which didn't find the executable.
18714     # The splitting of arguments from the executable at a space might have been incorrect,
18715     # since paths with space are more likely in Windows. Give it another try with the whole
18716     # argument.
18717     path="$complete"
18718     arguments="EOL"
18719     new_path=`$CYGPATH -u "$path"`
18720     new_path=`$WHICH "$new_path" 2> /dev/null`
18721     # bat and cmd files are not always considered executable in cygwin causing which
18722     # to not find them
18723     if test "x$new_path" = x \
18724         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18725         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18726       new_path=`$CYGPATH -u "$path"`
18727     fi
18728     if test "x$new_path" = x; then
18729       # It's still not found. Now this is an unrecoverable error.
18730       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18731 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18732       has_space=`$ECHO "$complete" | $GREP " "`
18733       if test "x$has_space" != x; then
18734         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
18735 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
18736       fi
18737       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18738     fi
18739   fi
18740 
18741   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
18742   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
18743   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
18744   # "foo.exe" is OK but "foo" is an error.
18745   #
18746   # This test is therefore slightly more accurate than "test -f" to check for file presence.
18747   # It is also a way to make sure we got the proper file name for the real test later on.
18748   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
18749   if test "x$test_shortpath" = x; then
18750     # Short path failed, file does not exist as specified.
18751     # Try adding .exe or .cmd
18752     if test -f "${new_path}.exe"; then
18753       input_to_shortpath="${new_path}.exe"
18754     elif test -f "${new_path}.cmd"; then
18755       input_to_shortpath="${new_path}.cmd"
18756     else
18757       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
18758 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
18759       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
18760 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
18761       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18762     fi
18763   else
18764     input_to_shortpath="$new_path"
18765   fi
18766 
18767   # Call helper function which possibly converts this using DOS-style short mode.
18768   # If so, the updated path is stored in $new_path.
18769   new_path="$input_to_shortpath"
18770 
18771   input_path="$input_to_shortpath"
18772   # Check if we need to convert this using DOS-style short mode. If the path
18773   # contains just simple characters, use it. Otherwise (spaces, weird characters),
18774   # take no chances and rewrite it.
18775   # Note: m4 eats our [], so we need to use [ and ] instead.
18776   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
18777   if test "x$has_forbidden_chars" != x; then
18778     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
18779     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
18780     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
18781     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
18782       # Going to short mode and back again did indeed matter. Since short mode is
18783       # case insensitive, let's make it lowercase to improve readability.
18784       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
18785       # Now convert it back to Unix-style (cygpath)
18786       input_path=`$CYGPATH -u "$shortmode_path"`
18787       new_path="$input_path"
18788     fi
18789   fi
18790 
18791   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
18792   if test "x$test_cygdrive_prefix" = x; then
18793     # As a simple fix, exclude /usr/bin since it's not a real path.
18794     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
18795       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
18796       # a path prefixed by /cygdrive for fixpath to work.
18797       new_path="$CYGWIN_ROOT_PATH$input_path"
18798     fi
18799   fi
18800 
18801   # remove trailing .exe if any
18802   new_path="${new_path/%.exe/}"
18803 
18804     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18805 
18806   # First separate the path from the arguments. This will split at the first
18807   # space.
18808   complete="$FOUND_MAKE"
18809   path="${complete%% *}"
18810   tmp="$complete EOL"
18811   arguments="${tmp#* }"
18812 
18813   # Input might be given as Windows format, start by converting to
18814   # unix format.
18815   new_path="$path"
18816 
18817   windows_path="$new_path"
18818   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18819     unix_path=`$CYGPATH -u "$windows_path"`
18820     new_path="$unix_path"
18821   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18822     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18823     new_path="$unix_path"
18824   fi
18825 
18826 
18827   # Now try to locate executable using which
18828   new_path=`$WHICH "$new_path" 2> /dev/null`
18829 
18830   if test "x$new_path" = x; then
18831     # Oops. Which didn't find the executable.
18832     # The splitting of arguments from the executable at a space might have been incorrect,
18833     # since paths with space are more likely in Windows. Give it another try with the whole
18834     # argument.
18835     path="$complete"
18836     arguments="EOL"
18837     new_path="$path"
18838 
18839   windows_path="$new_path"
18840   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18841     unix_path=`$CYGPATH -u "$windows_path"`
18842     new_path="$unix_path"
18843   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18844     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18845     new_path="$unix_path"
18846   fi
18847 
18848 
18849     new_path=`$WHICH "$new_path" 2> /dev/null`
18850     # bat and cmd files are not always considered executable in MSYS causing which
18851     # to not find them
18852     if test "x$new_path" = x \
18853         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18854         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18855       new_path="$path"
18856 
18857   windows_path="$new_path"
18858   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18859     unix_path=`$CYGPATH -u "$windows_path"`
18860     new_path="$unix_path"
18861   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18862     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18863     new_path="$unix_path"
18864   fi
18865 
18866     fi
18867 
18868     if test "x$new_path" = x; then
18869       # It's still not found. Now this is an unrecoverable error.
18870       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18871 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18872       has_space=`$ECHO "$complete" | $GREP " "`
18873       if test "x$has_space" != x; then
18874         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
18875 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
18876       fi
18877       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18878     fi
18879   fi
18880 
18881   # Now new_path has a complete unix path to the binary
18882   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
18883     # Keep paths in /bin as-is, but remove trailing .exe if any
18884     new_path="${new_path/%.exe/}"
18885     # Do not save /bin paths to all_fixpath_prefixes!
18886   else
18887     # Not in mixed or Windows style, start by that.
18888     new_path=`cmd //c echo $new_path`
18889 
18890   input_path="$new_path"
18891   # Check if we need to convert this using DOS-style short mode. If the path
18892   # contains just simple characters, use it. Otherwise (spaces, weird characters),
18893   # take no chances and rewrite it.
18894   # Note: m4 eats our [], so we need to use [ and ] instead.
18895   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
18896   if test "x$has_forbidden_chars" != x; then
18897     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
18898     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
18899   fi
18900 
18901     # Output is in $new_path
18902 
18903   windows_path="$new_path"
18904   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18905     unix_path=`$CYGPATH -u "$windows_path"`
18906     new_path="$unix_path"
18907   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18908     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18909     new_path="$unix_path"
18910   fi
18911 
18912     # remove trailing .exe if any
18913     new_path="${new_path/%.exe/}"
18914 
18915     # Save the first 10 bytes of this path to the storage, so fixpath can work.
18916     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
18917   fi
18918 
18919     else
18920       # We're on a unix platform. Hooray! :)
18921       # First separate the path from the arguments. This will split at the first
18922       # space.
18923       complete="$FOUND_MAKE"
18924       path="${complete%% *}"
18925       tmp="$complete EOL"
18926       arguments="${tmp#* }"
18927 
18928       # Cannot rely on the command "which" here since it doesn't always work.
18929       is_absolute_path=`$ECHO "$path" | $GREP ^/`
18930       if test -z "$is_absolute_path"; then
18931         # Path to executable is not absolute. Find it.
18932         IFS_save="$IFS"
18933         IFS=:
18934         for p in $PATH; do
18935           if test -f "$p/$path" && test -x "$p/$path"; then
18936             new_path="$p/$path"
18937             break
18938           fi
18939         done
18940         IFS="$IFS_save"
18941       else
18942         # This is an absolute path, we can use it without further modifications.
18943         new_path="$path"
18944       fi
18945 
18946       if test "x$new_path" = x; then
18947         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18948 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18949         has_space=`$ECHO "$complete" | $GREP " "`
18950         if test "x$has_space" != x; then
18951           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
18952 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
18953         fi
18954         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18955       fi
18956     fi
18957 
18958     # Now join together the path and the arguments once again
18959     if test "x$arguments" != xEOL; then
18960       new_complete="$new_path ${arguments% *}"
18961     else
18962       new_complete="$new_path"
18963     fi
18964 
18965     if test "x$complete" != "x$new_complete"; then
18966       FOUND_MAKE="$new_complete"
18967       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
18968 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
18969     fi
18970   fi
18971 
18972         fi
18973       fi
18974     fi
18975   fi
18976 
18977     fi
18978 
18979     if test "x$FOUND_MAKE" = x; then
18980       if test "x$TOOLCHAIN_PATH" != x; then
18981         # We have a toolchain path, check that as well before giving up.
18982         OLD_PATH=$PATH
18983         PATH=$TOOLCHAIN_PATH:$PATH
18984         for ac_prog in gmake
18985 do
18986   # Extract the first word of "$ac_prog", so it can be a program name with args.
18987 set dummy $ac_prog; ac_word=$2
18988 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18989 $as_echo_n "checking for $ac_word... " >&6; }
18990 if ${ac_cv_path_CHECK_TOOLSDIR_GMAKE+:} false; then :
18991   $as_echo_n "(cached) " >&6
18992 else
18993   case $CHECK_TOOLSDIR_GMAKE in
18994   [\\/]* | ?:[\\/]*)
18995   ac_cv_path_CHECK_TOOLSDIR_GMAKE="$CHECK_TOOLSDIR_GMAKE" # Let the user override the test with a path.
18996   ;;
18997   *)
18998   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18999 for as_dir in $PATH
19000 do
19001   IFS=$as_save_IFS
19002   test -z "$as_dir" && as_dir=.
19003     for ac_exec_ext in '' $ac_executable_extensions; do
19004   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19005     ac_cv_path_CHECK_TOOLSDIR_GMAKE="$as_dir/$ac_word$ac_exec_ext"
19006     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19007     break 2
19008   fi
19009 done
19010   done
19011 IFS=$as_save_IFS
19012 
19013   ;;
19014 esac
19015 fi
19016 CHECK_TOOLSDIR_GMAKE=$ac_cv_path_CHECK_TOOLSDIR_GMAKE
19017 if test -n "$CHECK_TOOLSDIR_GMAKE"; then
19018   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_GMAKE" >&5
19019 $as_echo "$CHECK_TOOLSDIR_GMAKE" >&6; }
19020 else
19021   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19022 $as_echo "no" >&6; }
19023 fi
19024 
19025 
19026   test -n "$CHECK_TOOLSDIR_GMAKE" && break
19027 done
19028 
19029 
19030   MAKE_CANDIDATE=""$CHECK_TOOLSDIR_GMAKE""
19031   DESCRIPTION="gmake in tools-dir"
19032 
19033   # On Cygwin, we require a newer version of make than on other platforms
19034   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19035     MAKE_VERSION_EXPR="-e 4\."
19036     MAKE_REQUIRED_VERSION="4.0"
19037    else
19038     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
19039     MAKE_REQUIRED_VERSION="3.81"
19040   fi
19041 
19042   if test "x$MAKE_CANDIDATE" != x; then
19043     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
19044 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
19045     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
19046     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
19047     if test "x$IS_GNU_MAKE" = x; then
19048       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
19049 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
19050     else
19051       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
19052       if test "x$IS_MODERN_MAKE" = x; then
19053         { $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
19054 $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;}
19055       else
19056         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
19057           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19058             MAKE_EXPECTED_ENV='cygwin'
19059           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19060             MAKE_EXPECTED_ENV='msys'
19061           else
19062             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
19063           fi
19064           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
19065           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
19066         else
19067           # Not relevant for non-Windows
19068           IS_MAKE_CORRECT_ENV=true
19069         fi
19070         if test "x$IS_MAKE_CORRECT_ENV" = x; then
19071           { $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
19072 $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;}
19073         else
19074           FOUND_MAKE=$MAKE_CANDIDATE
19075 
19076   # Only process if variable expands to non-empty
19077 
19078   if test "x$FOUND_MAKE" != x; then
19079     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19080 
19081   # First separate the path from the arguments. This will split at the first
19082   # space.
19083   complete="$FOUND_MAKE"
19084   path="${complete%% *}"
19085   tmp="$complete EOL"
19086   arguments="${tmp#* }"
19087 
19088   # Input might be given as Windows format, start by converting to
19089   # unix format.
19090   new_path=`$CYGPATH -u "$path"`
19091 
19092   # Now try to locate executable using which
19093   new_path=`$WHICH "$new_path" 2> /dev/null`
19094   # bat and cmd files are not always considered executable in cygwin causing which
19095   # to not find them
19096   if test "x$new_path" = x \
19097       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19098       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19099     new_path=`$CYGPATH -u "$path"`
19100   fi
19101   if test "x$new_path" = x; then
19102     # Oops. Which didn't find the executable.
19103     # The splitting of arguments from the executable at a space might have been incorrect,
19104     # since paths with space are more likely in Windows. Give it another try with the whole
19105     # argument.
19106     path="$complete"
19107     arguments="EOL"
19108     new_path=`$CYGPATH -u "$path"`
19109     new_path=`$WHICH "$new_path" 2> /dev/null`
19110     # bat and cmd files are not always considered executable in cygwin causing which
19111     # to not find them
19112     if test "x$new_path" = x \
19113         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19114         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19115       new_path=`$CYGPATH -u "$path"`
19116     fi
19117     if test "x$new_path" = x; then
19118       # It's still not found. Now this is an unrecoverable error.
19119       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19120 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19121       has_space=`$ECHO "$complete" | $GREP " "`
19122       if test "x$has_space" != x; then
19123         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
19124 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
19125       fi
19126       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19127     fi
19128   fi
19129 
19130   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
19131   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
19132   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
19133   # "foo.exe" is OK but "foo" is an error.
19134   #
19135   # This test is therefore slightly more accurate than "test -f" to check for file presence.
19136   # It is also a way to make sure we got the proper file name for the real test later on.
19137   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
19138   if test "x$test_shortpath" = x; then
19139     # Short path failed, file does not exist as specified.
19140     # Try adding .exe or .cmd
19141     if test -f "${new_path}.exe"; then
19142       input_to_shortpath="${new_path}.exe"
19143     elif test -f "${new_path}.cmd"; then
19144       input_to_shortpath="${new_path}.cmd"
19145     else
19146       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
19147 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
19148       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
19149 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
19150       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19151     fi
19152   else
19153     input_to_shortpath="$new_path"
19154   fi
19155 
19156   # Call helper function which possibly converts this using DOS-style short mode.
19157   # If so, the updated path is stored in $new_path.
19158   new_path="$input_to_shortpath"
19159 
19160   input_path="$input_to_shortpath"
19161   # Check if we need to convert this using DOS-style short mode. If the path
19162   # contains just simple characters, use it. Otherwise (spaces, weird characters),
19163   # take no chances and rewrite it.
19164   # Note: m4 eats our [], so we need to use [ and ] instead.
19165   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
19166   if test "x$has_forbidden_chars" != x; then
19167     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
19168     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
19169     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
19170     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
19171       # Going to short mode and back again did indeed matter. Since short mode is
19172       # case insensitive, let's make it lowercase to improve readability.
19173       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
19174       # Now convert it back to Unix-style (cygpath)
19175       input_path=`$CYGPATH -u "$shortmode_path"`
19176       new_path="$input_path"
19177     fi
19178   fi
19179 
19180   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
19181   if test "x$test_cygdrive_prefix" = x; then
19182     # As a simple fix, exclude /usr/bin since it's not a real path.
19183     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
19184       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
19185       # a path prefixed by /cygdrive for fixpath to work.
19186       new_path="$CYGWIN_ROOT_PATH$input_path"
19187     fi
19188   fi
19189 
19190   # remove trailing .exe if any
19191   new_path="${new_path/%.exe/}"
19192 
19193     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19194 
19195   # First separate the path from the arguments. This will split at the first
19196   # space.
19197   complete="$FOUND_MAKE"
19198   path="${complete%% *}"
19199   tmp="$complete EOL"
19200   arguments="${tmp#* }"
19201 
19202   # Input might be given as Windows format, start by converting to
19203   # unix format.
19204   new_path="$path"
19205 
19206   windows_path="$new_path"
19207   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19208     unix_path=`$CYGPATH -u "$windows_path"`
19209     new_path="$unix_path"
19210   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19211     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19212     new_path="$unix_path"
19213   fi
19214 
19215 
19216   # Now try to locate executable using which
19217   new_path=`$WHICH "$new_path" 2> /dev/null`
19218 
19219   if test "x$new_path" = x; then
19220     # Oops. Which didn't find the executable.
19221     # The splitting of arguments from the executable at a space might have been incorrect,
19222     # since paths with space are more likely in Windows. Give it another try with the whole
19223     # argument.
19224     path="$complete"
19225     arguments="EOL"
19226     new_path="$path"
19227 
19228   windows_path="$new_path"
19229   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19230     unix_path=`$CYGPATH -u "$windows_path"`
19231     new_path="$unix_path"
19232   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19233     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19234     new_path="$unix_path"
19235   fi
19236 
19237 
19238     new_path=`$WHICH "$new_path" 2> /dev/null`
19239     # bat and cmd files are not always considered executable in MSYS causing which
19240     # to not find them
19241     if test "x$new_path" = x \
19242         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19243         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19244       new_path="$path"
19245 
19246   windows_path="$new_path"
19247   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19248     unix_path=`$CYGPATH -u "$windows_path"`
19249     new_path="$unix_path"
19250   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19251     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19252     new_path="$unix_path"
19253   fi
19254 
19255     fi
19256 
19257     if test "x$new_path" = x; then
19258       # It's still not found. Now this is an unrecoverable error.
19259       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19260 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19261       has_space=`$ECHO "$complete" | $GREP " "`
19262       if test "x$has_space" != x; then
19263         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
19264 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
19265       fi
19266       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19267     fi
19268   fi
19269 
19270   # Now new_path has a complete unix path to the binary
19271   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
19272     # Keep paths in /bin as-is, but remove trailing .exe if any
19273     new_path="${new_path/%.exe/}"
19274     # Do not save /bin paths to all_fixpath_prefixes!
19275   else
19276     # Not in mixed or Windows style, start by that.
19277     new_path=`cmd //c echo $new_path`
19278 
19279   input_path="$new_path"
19280   # Check if we need to convert this using DOS-style short mode. If the path
19281   # contains just simple characters, use it. Otherwise (spaces, weird characters),
19282   # take no chances and rewrite it.
19283   # Note: m4 eats our [], so we need to use [ and ] instead.
19284   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
19285   if test "x$has_forbidden_chars" != x; then
19286     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
19287     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
19288   fi
19289 
19290     # Output is in $new_path
19291 
19292   windows_path="$new_path"
19293   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19294     unix_path=`$CYGPATH -u "$windows_path"`
19295     new_path="$unix_path"
19296   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19297     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19298     new_path="$unix_path"
19299   fi
19300 
19301     # remove trailing .exe if any
19302     new_path="${new_path/%.exe/}"
19303 
19304     # Save the first 10 bytes of this path to the storage, so fixpath can work.
19305     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
19306   fi
19307 
19308     else
19309       # We're on a unix platform. Hooray! :)
19310       # First separate the path from the arguments. This will split at the first
19311       # space.
19312       complete="$FOUND_MAKE"
19313       path="${complete%% *}"
19314       tmp="$complete EOL"
19315       arguments="${tmp#* }"
19316 
19317       # Cannot rely on the command "which" here since it doesn't always work.
19318       is_absolute_path=`$ECHO "$path" | $GREP ^/`
19319       if test -z "$is_absolute_path"; then
19320         # Path to executable is not absolute. Find it.
19321         IFS_save="$IFS"
19322         IFS=:
19323         for p in $PATH; do
19324           if test -f "$p/$path" && test -x "$p/$path"; then
19325             new_path="$p/$path"
19326             break
19327           fi
19328         done
19329         IFS="$IFS_save"
19330       else
19331         # This is an absolute path, we can use it without further modifications.
19332         new_path="$path"
19333       fi
19334 
19335       if test "x$new_path" = x; then
19336         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19337 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19338         has_space=`$ECHO "$complete" | $GREP " "`
19339         if test "x$has_space" != x; then
19340           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
19341 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
19342         fi
19343         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19344       fi
19345     fi
19346 
19347     # Now join together the path and the arguments once again
19348     if test "x$arguments" != xEOL; then
19349       new_complete="$new_path ${arguments% *}"
19350     else
19351       new_complete="$new_path"
19352     fi
19353 
19354     if test "x$complete" != "x$new_complete"; then
19355       FOUND_MAKE="$new_complete"
19356       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
19357 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
19358     fi
19359   fi
19360 
19361         fi
19362       fi
19363     fi
19364   fi
19365 
19366         if test "x$FOUND_MAKE" = x; then
19367           for ac_prog in make
19368 do
19369   # Extract the first word of "$ac_prog", so it can be a program name with args.
19370 set dummy $ac_prog; ac_word=$2
19371 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19372 $as_echo_n "checking for $ac_word... " >&6; }
19373 if ${ac_cv_path_CHECK_TOOLSDIR_MAKE+:} false; then :
19374   $as_echo_n "(cached) " >&6
19375 else
19376   case $CHECK_TOOLSDIR_MAKE in
19377   [\\/]* | ?:[\\/]*)
19378   ac_cv_path_CHECK_TOOLSDIR_MAKE="$CHECK_TOOLSDIR_MAKE" # Let the user override the test with a path.
19379   ;;
19380   *)
19381   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19382 for as_dir in $PATH
19383 do
19384   IFS=$as_save_IFS
19385   test -z "$as_dir" && as_dir=.
19386     for ac_exec_ext in '' $ac_executable_extensions; do
19387   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19388     ac_cv_path_CHECK_TOOLSDIR_MAKE="$as_dir/$ac_word$ac_exec_ext"
19389     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19390     break 2
19391   fi
19392 done
19393   done
19394 IFS=$as_save_IFS
19395 
19396   ;;
19397 esac
19398 fi
19399 CHECK_TOOLSDIR_MAKE=$ac_cv_path_CHECK_TOOLSDIR_MAKE
19400 if test -n "$CHECK_TOOLSDIR_MAKE"; then
19401   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_MAKE" >&5
19402 $as_echo "$CHECK_TOOLSDIR_MAKE" >&6; }
19403 else
19404   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19405 $as_echo "no" >&6; }
19406 fi
19407 
19408 
19409   test -n "$CHECK_TOOLSDIR_MAKE" && break
19410 done
19411 
19412 
19413   MAKE_CANDIDATE=""$CHECK_TOOLSDIR_MAKE""
19414   DESCRIPTION="make in tools-dir"
19415 
19416   # On Cygwin, we require a newer version of make than on other platforms
19417   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19418     MAKE_VERSION_EXPR="-e 4\."
19419     MAKE_REQUIRED_VERSION="4.0"
19420    else
19421     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
19422     MAKE_REQUIRED_VERSION="3.81"
19423   fi
19424 
19425   if test "x$MAKE_CANDIDATE" != x; then
19426     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
19427 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
19428     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
19429     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
19430     if test "x$IS_GNU_MAKE" = x; then
19431       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
19432 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
19433     else
19434       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
19435       if test "x$IS_MODERN_MAKE" = x; then
19436         { $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
19437 $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;}
19438       else
19439         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
19440           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19441             MAKE_EXPECTED_ENV='cygwin'
19442           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19443             MAKE_EXPECTED_ENV='msys'
19444           else
19445             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
19446           fi
19447           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
19448           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
19449         else
19450           # Not relevant for non-Windows
19451           IS_MAKE_CORRECT_ENV=true
19452         fi
19453         if test "x$IS_MAKE_CORRECT_ENV" = x; then
19454           { $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
19455 $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;}
19456         else
19457           FOUND_MAKE=$MAKE_CANDIDATE
19458 
19459   # Only process if variable expands to non-empty
19460 
19461   if test "x$FOUND_MAKE" != x; then
19462     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19463 
19464   # First separate the path from the arguments. This will split at the first
19465   # space.
19466   complete="$FOUND_MAKE"
19467   path="${complete%% *}"
19468   tmp="$complete EOL"
19469   arguments="${tmp#* }"
19470 
19471   # Input might be given as Windows format, start by converting to
19472   # unix format.
19473   new_path=`$CYGPATH -u "$path"`
19474 
19475   # Now try to locate executable using which
19476   new_path=`$WHICH "$new_path" 2> /dev/null`
19477   # bat and cmd files are not always considered executable in cygwin causing which
19478   # to not find them
19479   if test "x$new_path" = x \
19480       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19481       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19482     new_path=`$CYGPATH -u "$path"`
19483   fi
19484   if test "x$new_path" = x; then
19485     # Oops. Which didn't find the executable.
19486     # The splitting of arguments from the executable at a space might have been incorrect,
19487     # since paths with space are more likely in Windows. Give it another try with the whole
19488     # argument.
19489     path="$complete"
19490     arguments="EOL"
19491     new_path=`$CYGPATH -u "$path"`
19492     new_path=`$WHICH "$new_path" 2> /dev/null`
19493     # bat and cmd files are not always considered executable in cygwin causing which
19494     # to not find them
19495     if test "x$new_path" = x \
19496         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19497         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19498       new_path=`$CYGPATH -u "$path"`
19499     fi
19500     if test "x$new_path" = x; then
19501       # It's still not found. Now this is an unrecoverable error.
19502       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19503 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19504       has_space=`$ECHO "$complete" | $GREP " "`
19505       if test "x$has_space" != x; then
19506         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
19507 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
19508       fi
19509       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19510     fi
19511   fi
19512 
19513   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
19514   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
19515   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
19516   # "foo.exe" is OK but "foo" is an error.
19517   #
19518   # This test is therefore slightly more accurate than "test -f" to check for file presence.
19519   # It is also a way to make sure we got the proper file name for the real test later on.
19520   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
19521   if test "x$test_shortpath" = x; then
19522     # Short path failed, file does not exist as specified.
19523     # Try adding .exe or .cmd
19524     if test -f "${new_path}.exe"; then
19525       input_to_shortpath="${new_path}.exe"
19526     elif test -f "${new_path}.cmd"; then
19527       input_to_shortpath="${new_path}.cmd"
19528     else
19529       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
19530 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
19531       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
19532 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
19533       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19534     fi
19535   else
19536     input_to_shortpath="$new_path"
19537   fi
19538 
19539   # Call helper function which possibly converts this using DOS-style short mode.
19540   # If so, the updated path is stored in $new_path.
19541   new_path="$input_to_shortpath"
19542 
19543   input_path="$input_to_shortpath"
19544   # Check if we need to convert this using DOS-style short mode. If the path
19545   # contains just simple characters, use it. Otherwise (spaces, weird characters),
19546   # take no chances and rewrite it.
19547   # Note: m4 eats our [], so we need to use [ and ] instead.
19548   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
19549   if test "x$has_forbidden_chars" != x; then
19550     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
19551     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
19552     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
19553     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
19554       # Going to short mode and back again did indeed matter. Since short mode is
19555       # case insensitive, let's make it lowercase to improve readability.
19556       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
19557       # Now convert it back to Unix-style (cygpath)
19558       input_path=`$CYGPATH -u "$shortmode_path"`
19559       new_path="$input_path"
19560     fi
19561   fi
19562 
19563   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
19564   if test "x$test_cygdrive_prefix" = x; then
19565     # As a simple fix, exclude /usr/bin since it's not a real path.
19566     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
19567       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
19568       # a path prefixed by /cygdrive for fixpath to work.
19569       new_path="$CYGWIN_ROOT_PATH$input_path"
19570     fi
19571   fi
19572 
19573   # remove trailing .exe if any
19574   new_path="${new_path/%.exe/}"
19575 
19576     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19577 
19578   # First separate the path from the arguments. This will split at the first
19579   # space.
19580   complete="$FOUND_MAKE"
19581   path="${complete%% *}"
19582   tmp="$complete EOL"
19583   arguments="${tmp#* }"
19584 
19585   # Input might be given as Windows format, start by converting to
19586   # unix format.
19587   new_path="$path"
19588 
19589   windows_path="$new_path"
19590   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19591     unix_path=`$CYGPATH -u "$windows_path"`
19592     new_path="$unix_path"
19593   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19594     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19595     new_path="$unix_path"
19596   fi
19597 
19598 
19599   # Now try to locate executable using which
19600   new_path=`$WHICH "$new_path" 2> /dev/null`
19601 
19602   if test "x$new_path" = x; then
19603     # Oops. Which didn't find the executable.
19604     # The splitting of arguments from the executable at a space might have been incorrect,
19605     # since paths with space are more likely in Windows. Give it another try with the whole
19606     # argument.
19607     path="$complete"
19608     arguments="EOL"
19609     new_path="$path"
19610 
19611   windows_path="$new_path"
19612   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19613     unix_path=`$CYGPATH -u "$windows_path"`
19614     new_path="$unix_path"
19615   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19616     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19617     new_path="$unix_path"
19618   fi
19619 
19620 
19621     new_path=`$WHICH "$new_path" 2> /dev/null`
19622     # bat and cmd files are not always considered executable in MSYS causing which
19623     # to not find them
19624     if test "x$new_path" = x \
19625         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19626         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19627       new_path="$path"
19628 
19629   windows_path="$new_path"
19630   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19631     unix_path=`$CYGPATH -u "$windows_path"`
19632     new_path="$unix_path"
19633   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19634     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19635     new_path="$unix_path"
19636   fi
19637 
19638     fi
19639 
19640     if test "x$new_path" = x; then
19641       # It's still not found. Now this is an unrecoverable error.
19642       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19643 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19644       has_space=`$ECHO "$complete" | $GREP " "`
19645       if test "x$has_space" != x; then
19646         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
19647 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
19648       fi
19649       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19650     fi
19651   fi
19652 
19653   # Now new_path has a complete unix path to the binary
19654   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
19655     # Keep paths in /bin as-is, but remove trailing .exe if any
19656     new_path="${new_path/%.exe/}"
19657     # Do not save /bin paths to all_fixpath_prefixes!
19658   else
19659     # Not in mixed or Windows style, start by that.
19660     new_path=`cmd //c echo $new_path`
19661 
19662   input_path="$new_path"
19663   # Check if we need to convert this using DOS-style short mode. If the path
19664   # contains just simple characters, use it. Otherwise (spaces, weird characters),
19665   # take no chances and rewrite it.
19666   # Note: m4 eats our [], so we need to use [ and ] instead.
19667   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
19668   if test "x$has_forbidden_chars" != x; then
19669     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
19670     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
19671   fi
19672 
19673     # Output is in $new_path
19674 
19675   windows_path="$new_path"
19676   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19677     unix_path=`$CYGPATH -u "$windows_path"`
19678     new_path="$unix_path"
19679   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19680     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19681     new_path="$unix_path"
19682   fi
19683 
19684     # remove trailing .exe if any
19685     new_path="${new_path/%.exe/}"
19686 
19687     # Save the first 10 bytes of this path to the storage, so fixpath can work.
19688     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
19689   fi
19690 
19691     else
19692       # We're on a unix platform. Hooray! :)
19693       # First separate the path from the arguments. This will split at the first
19694       # space.
19695       complete="$FOUND_MAKE"
19696       path="${complete%% *}"
19697       tmp="$complete EOL"
19698       arguments="${tmp#* }"
19699 
19700       # Cannot rely on the command "which" here since it doesn't always work.
19701       is_absolute_path=`$ECHO "$path" | $GREP ^/`
19702       if test -z "$is_absolute_path"; then
19703         # Path to executable is not absolute. Find it.
19704         IFS_save="$IFS"
19705         IFS=:
19706         for p in $PATH; do
19707           if test -f "$p/$path" && test -x "$p/$path"; then
19708             new_path="$p/$path"
19709             break
19710           fi
19711         done
19712         IFS="$IFS_save"
19713       else
19714         # This is an absolute path, we can use it without further modifications.
19715         new_path="$path"
19716       fi
19717 
19718       if test "x$new_path" = x; then
19719         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19720 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19721         has_space=`$ECHO "$complete" | $GREP " "`
19722         if test "x$has_space" != x; then
19723           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
19724 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
19725         fi
19726         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19727       fi
19728     fi
19729 
19730     # Now join together the path and the arguments once again
19731     if test "x$arguments" != xEOL; then
19732       new_complete="$new_path ${arguments% *}"
19733     else
19734       new_complete="$new_path"
19735     fi
19736 
19737     if test "x$complete" != "x$new_complete"; then
19738       FOUND_MAKE="$new_complete"
19739       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
19740 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
19741     fi
19742   fi
19743 
19744         fi
19745       fi
19746     fi
19747   fi
19748 
19749         fi
19750         PATH=$OLD_PATH
19751       fi
19752     fi
19753 
19754     if test "x$FOUND_MAKE" = x; then
19755       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
19756     fi
19757 
19758     else
19759       # If it succeeded, then it was overridden by the user. We will use it
19760       # for the tool.
19761 
19762       # First remove it from the list of overridden variables, so we can test
19763       # for unknown variables in the end.
19764       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
19765 
19766       # Check if we try to supply an empty value
19767       if test "x$MAKE" = x; then
19768         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool MAKE= (no value)" >&5
19769 $as_echo "$as_me: Setting user supplied tool MAKE= (no value)" >&6;}
19770         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MAKE" >&5
19771 $as_echo_n "checking for MAKE... " >&6; }
19772         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
19773 $as_echo "disabled" >&6; }
19774       else
19775         # Check if the provided tool contains a complete path.
19776         tool_specified="$MAKE"
19777         tool_basename="${tool_specified##*/}"
19778         if test "x$tool_basename" = "x$tool_specified"; then
19779           # A command without a complete path is provided, search $PATH.
19780           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MAKE=$tool_basename" >&5
19781 $as_echo "$as_me: Will search for user supplied tool MAKE=$tool_basename" >&6;}
19782           # Extract the first word of "$tool_basename", so it can be a program name with args.
19783 set dummy $tool_basename; ac_word=$2
19784 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19785 $as_echo_n "checking for $ac_word... " >&6; }
19786 if ${ac_cv_path_MAKE+:} false; then :
19787   $as_echo_n "(cached) " >&6
19788 else
19789   case $MAKE in
19790   [\\/]* | ?:[\\/]*)
19791   ac_cv_path_MAKE="$MAKE" # Let the user override the test with a path.
19792   ;;
19793   *)
19794   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19795 for as_dir in $PATH
19796 do
19797   IFS=$as_save_IFS
19798   test -z "$as_dir" && as_dir=.
19799     for ac_exec_ext in '' $ac_executable_extensions; do
19800   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19801     ac_cv_path_MAKE="$as_dir/$ac_word$ac_exec_ext"
19802     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19803     break 2
19804   fi
19805 done
19806   done
19807 IFS=$as_save_IFS
19808 
19809   ;;
19810 esac
19811 fi
19812 MAKE=$ac_cv_path_MAKE
19813 if test -n "$MAKE"; then
19814   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MAKE" >&5
19815 $as_echo "$MAKE" >&6; }
19816 else
19817   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19818 $as_echo "no" >&6; }
19819 fi
19820 
19821 
19822           if test "x$MAKE" = x; then
19823             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
19824           fi
19825         else
19826           # Otherwise we believe it is a complete path. Use it as it is.
19827           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MAKE=$tool_specified" >&5
19828 $as_echo "$as_me: Will use user supplied tool MAKE=$tool_specified" >&6;}
19829           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MAKE" >&5
19830 $as_echo_n "checking for MAKE... " >&6; }
19831           if test ! -x "$tool_specified"; then
19832             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
19833 $as_echo "not found" >&6; }
19834             as_fn_error $? "User supplied tool MAKE=$tool_specified does not exist or is not executable" "$LINENO" 5
19835           fi
19836           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
19837 $as_echo "$tool_specified" >&6; }
19838         fi
19839       fi
19840     fi
19841 
19842     # If MAKE was set by user, verify the version
19843 
19844   MAKE_CANDIDATE=""$MAKE""
19845   DESCRIPTION="user supplied MAKE=$MAKE"
19846 
19847   # On Cygwin, we require a newer version of make than on other platforms
19848   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19849     MAKE_VERSION_EXPR="-e 4\."
19850     MAKE_REQUIRED_VERSION="4.0"
19851    else
19852     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
19853     MAKE_REQUIRED_VERSION="3.81"
19854   fi
19855 
19856   if test "x$MAKE_CANDIDATE" != x; then
19857     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
19858 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
19859     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
19860     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
19861     if test "x$IS_GNU_MAKE" = x; then
19862       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
19863 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
19864     else
19865       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
19866       if test "x$IS_MODERN_MAKE" = x; then
19867         { $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
19868 $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;}
19869       else
19870         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
19871           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19872             MAKE_EXPECTED_ENV='cygwin'
19873           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19874             MAKE_EXPECTED_ENV='msys'
19875           else
19876             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
19877           fi
19878           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
19879           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
19880         else
19881           # Not relevant for non-Windows
19882           IS_MAKE_CORRECT_ENV=true
19883         fi
19884         if test "x$IS_MAKE_CORRECT_ENV" = x; then
19885           { $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
19886 $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;}
19887         else
19888           FOUND_MAKE=$MAKE_CANDIDATE
19889 
19890   # Only process if variable expands to non-empty
19891 
19892   if test "x$FOUND_MAKE" != x; then
19893     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19894 
19895   # First separate the path from the arguments. This will split at the first
19896   # space.
19897   complete="$FOUND_MAKE"
19898   path="${complete%% *}"
19899   tmp="$complete EOL"
19900   arguments="${tmp#* }"
19901 
19902   # Input might be given as Windows format, start by converting to
19903   # unix format.
19904   new_path=`$CYGPATH -u "$path"`
19905 
19906   # Now try to locate executable using which
19907   new_path=`$WHICH "$new_path" 2> /dev/null`
19908   # bat and cmd files are not always considered executable in cygwin causing which
19909   # to not find them
19910   if test "x$new_path" = x \
19911       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19912       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19913     new_path=`$CYGPATH -u "$path"`
19914   fi
19915   if test "x$new_path" = x; then
19916     # Oops. Which didn't find the executable.
19917     # The splitting of arguments from the executable at a space might have been incorrect,
19918     # since paths with space are more likely in Windows. Give it another try with the whole
19919     # argument.
19920     path="$complete"
19921     arguments="EOL"
19922     new_path=`$CYGPATH -u "$path"`
19923     new_path=`$WHICH "$new_path" 2> /dev/null`
19924     # bat and cmd files are not always considered executable in cygwin causing which
19925     # to not find them
19926     if test "x$new_path" = x \
19927         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19928         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19929       new_path=`$CYGPATH -u "$path"`
19930     fi
19931     if test "x$new_path" = x; then
19932       # It's still not found. Now this is an unrecoverable error.
19933       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19934 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19935       has_space=`$ECHO "$complete" | $GREP " "`
19936       if test "x$has_space" != x; then
19937         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
19938 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
19939       fi
19940       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19941     fi
19942   fi
19943 
19944   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
19945   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
19946   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
19947   # "foo.exe" is OK but "foo" is an error.
19948   #
19949   # This test is therefore slightly more accurate than "test -f" to check for file presence.
19950   # It is also a way to make sure we got the proper file name for the real test later on.
19951   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
19952   if test "x$test_shortpath" = x; then
19953     # Short path failed, file does not exist as specified.
19954     # Try adding .exe or .cmd
19955     if test -f "${new_path}.exe"; then
19956       input_to_shortpath="${new_path}.exe"
19957     elif test -f "${new_path}.cmd"; then
19958       input_to_shortpath="${new_path}.cmd"
19959     else
19960       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
19961 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
19962       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
19963 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
19964       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19965     fi
19966   else
19967     input_to_shortpath="$new_path"
19968   fi
19969 
19970   # Call helper function which possibly converts this using DOS-style short mode.
19971   # If so, the updated path is stored in $new_path.
19972   new_path="$input_to_shortpath"
19973 
19974   input_path="$input_to_shortpath"
19975   # Check if we need to convert this using DOS-style short mode. If the path
19976   # contains just simple characters, use it. Otherwise (spaces, weird characters),
19977   # take no chances and rewrite it.
19978   # Note: m4 eats our [], so we need to use [ and ] instead.
19979   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
19980   if test "x$has_forbidden_chars" != x; then
19981     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
19982     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
19983     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
19984     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
19985       # Going to short mode and back again did indeed matter. Since short mode is
19986       # case insensitive, let's make it lowercase to improve readability.
19987       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
19988       # Now convert it back to Unix-style (cygpath)
19989       input_path=`$CYGPATH -u "$shortmode_path"`
19990       new_path="$input_path"
19991     fi
19992   fi
19993 
19994   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
19995   if test "x$test_cygdrive_prefix" = x; then
19996     # As a simple fix, exclude /usr/bin since it's not a real path.
19997     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
19998       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
19999       # a path prefixed by /cygdrive for fixpath to work.
20000       new_path="$CYGWIN_ROOT_PATH$input_path"
20001     fi
20002   fi
20003 
20004   # remove trailing .exe if any
20005   new_path="${new_path/%.exe/}"
20006 
20007     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20008 
20009   # First separate the path from the arguments. This will split at the first
20010   # space.
20011   complete="$FOUND_MAKE"
20012   path="${complete%% *}"
20013   tmp="$complete EOL"
20014   arguments="${tmp#* }"
20015 
20016   # Input might be given as Windows format, start by converting to
20017   # unix format.
20018   new_path="$path"
20019 
20020   windows_path="$new_path"
20021   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20022     unix_path=`$CYGPATH -u "$windows_path"`
20023     new_path="$unix_path"
20024   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20025     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20026     new_path="$unix_path"
20027   fi
20028 
20029 
20030   # Now try to locate executable using which
20031   new_path=`$WHICH "$new_path" 2> /dev/null`
20032 
20033   if test "x$new_path" = x; then
20034     # Oops. Which didn't find the executable.
20035     # The splitting of arguments from the executable at a space might have been incorrect,
20036     # since paths with space are more likely in Windows. Give it another try with the whole
20037     # argument.
20038     path="$complete"
20039     arguments="EOL"
20040     new_path="$path"
20041 
20042   windows_path="$new_path"
20043   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20044     unix_path=`$CYGPATH -u "$windows_path"`
20045     new_path="$unix_path"
20046   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20047     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20048     new_path="$unix_path"
20049   fi
20050 
20051 
20052     new_path=`$WHICH "$new_path" 2> /dev/null`
20053     # bat and cmd files are not always considered executable in MSYS causing which
20054     # to not find them
20055     if test "x$new_path" = x \
20056         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
20057         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
20058       new_path="$path"
20059 
20060   windows_path="$new_path"
20061   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20062     unix_path=`$CYGPATH -u "$windows_path"`
20063     new_path="$unix_path"
20064   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20065     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20066     new_path="$unix_path"
20067   fi
20068 
20069     fi
20070 
20071     if test "x$new_path" = x; then
20072       # It's still not found. Now this is an unrecoverable error.
20073       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
20074 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
20075       has_space=`$ECHO "$complete" | $GREP " "`
20076       if test "x$has_space" != x; then
20077         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
20078 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
20079       fi
20080       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
20081     fi
20082   fi
20083 
20084   # Now new_path has a complete unix path to the binary
20085   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
20086     # Keep paths in /bin as-is, but remove trailing .exe if any
20087     new_path="${new_path/%.exe/}"
20088     # Do not save /bin paths to all_fixpath_prefixes!
20089   else
20090     # Not in mixed or Windows style, start by that.
20091     new_path=`cmd //c echo $new_path`
20092 
20093   input_path="$new_path"
20094   # Check if we need to convert this using DOS-style short mode. If the path
20095   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20096   # take no chances and rewrite it.
20097   # Note: m4 eats our [], so we need to use [ and ] instead.
20098   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20099   if test "x$has_forbidden_chars" != x; then
20100     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20101     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20102   fi
20103 
20104     # Output is in $new_path
20105 
20106   windows_path="$new_path"
20107   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20108     unix_path=`$CYGPATH -u "$windows_path"`
20109     new_path="$unix_path"
20110   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20111     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20112     new_path="$unix_path"
20113   fi
20114 
20115     # remove trailing .exe if any
20116     new_path="${new_path/%.exe/}"
20117 
20118     # Save the first 10 bytes of this path to the storage, so fixpath can work.
20119     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20120   fi
20121 
20122     else
20123       # We're on a unix platform. Hooray! :)
20124       # First separate the path from the arguments. This will split at the first
20125       # space.
20126       complete="$FOUND_MAKE"
20127       path="${complete%% *}"
20128       tmp="$complete EOL"
20129       arguments="${tmp#* }"
20130 
20131       # Cannot rely on the command "which" here since it doesn't always work.
20132       is_absolute_path=`$ECHO "$path" | $GREP ^/`
20133       if test -z "$is_absolute_path"; then
20134         # Path to executable is not absolute. Find it.
20135         IFS_save="$IFS"
20136         IFS=:
20137         for p in $PATH; do
20138           if test -f "$p/$path" && test -x "$p/$path"; then
20139             new_path="$p/$path"
20140             break
20141           fi
20142         done
20143         IFS="$IFS_save"
20144       else
20145         # This is an absolute path, we can use it without further modifications.
20146         new_path="$path"
20147       fi
20148 
20149       if test "x$new_path" = x; then
20150         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
20151 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
20152         has_space=`$ECHO "$complete" | $GREP " "`
20153         if test "x$has_space" != x; then
20154           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
20155 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
20156         fi
20157         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
20158       fi
20159     fi
20160 
20161     # Now join together the path and the arguments once again
20162     if test "x$arguments" != xEOL; then
20163       new_complete="$new_path ${arguments% *}"
20164     else
20165       new_complete="$new_path"
20166     fi
20167 
20168     if test "x$complete" != "x$new_complete"; then
20169       FOUND_MAKE="$new_complete"
20170       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
20171 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
20172     fi
20173   fi
20174 
20175         fi
20176       fi
20177     fi
20178   fi
20179 
20180     if test "x$FOUND_MAKE" = x; then
20181       as_fn_error $? "The specified make (by MAKE=$MAKE) is not GNU make $MAKE_REQUIRED_VERSION or newer." "$LINENO" 5
20182     fi
20183 
20184   fi
20185 
20186 
20187   MAKE=$FOUND_MAKE
20188 
20189   { $as_echo "$as_me:${as_lineno-$LINENO}: Using GNU make at $FOUND_MAKE (version: $MAKE_VERSION_STRING)" >&5
20190 $as_echo "$as_me: Using GNU make at $FOUND_MAKE (version: $MAKE_VERSION_STRING)" >&6;}
20191 
20192 
20193   # Check if make supports the output sync option and if so, setup using it.
20194   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if make --output-sync is supported" >&5
20195 $as_echo_n "checking if make --output-sync is supported... " >&6; }
20196   if $MAKE --version -O > /dev/null 2>&1; then
20197     OUTPUT_SYNC_SUPPORTED=true
20198     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
20199 $as_echo "yes" >&6; }
20200     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for output-sync value" >&5
20201 $as_echo_n "checking for output-sync value... " >&6; }
20202 
20203 # Check whether --with-output-sync was given.
20204 if test "${with_output_sync+set}" = set; then :
20205   withval=$with_output_sync; OUTPUT_SYNC=$with_output_sync
20206 fi
20207 
20208     if test "x$OUTPUT_SYNC" = "x"; then
20209       OUTPUT_SYNC=none
20210     fi
20211     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OUTPUT_SYNC" >&5
20212 $as_echo "$OUTPUT_SYNC" >&6; }
20213     if ! $MAKE --version -O$OUTPUT_SYNC > /dev/null 2>&1; then
20214       as_fn_error $? "Make did not the support the value $OUTPUT_SYNC as output sync type." "$LINENO" 5
20215     fi
20216   else
20217     OUTPUT_SYNC_SUPPORTED=false
20218     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20219 $as_echo "no" >&6; }
20220   fi
20221 
20222 
20223 
20224 
20225 
20226 
20227   # Test if find supports -delete
20228   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if find supports -delete" >&5
20229 $as_echo_n "checking if find supports -delete... " >&6; }
20230   FIND_DELETE="-delete"
20231 
20232   DELETEDIR=`$MKTEMP -d tmp.XXXXXXXXXX` || (echo Could not create temporary directory!; exit $?)
20233 
20234   echo Hejsan > $DELETEDIR/TestIfFindSupportsDelete
20235 
20236   TEST_DELETE=`$FIND "$DELETEDIR" -name TestIfFindSupportsDelete $FIND_DELETE 2>&1`
20237   if test -f $DELETEDIR/TestIfFindSupportsDelete; then
20238     # No, it does not.
20239     rm $DELETEDIR/TestIfFindSupportsDelete
20240     if test "x$OPENJDK_TARGET_OS" = "xaix"; then
20241       # AIX 'find' is buggy if called with '-exec {} \+' and an empty file list
20242       FIND_DELETE="-print | xargs rm"
20243     else
20244       FIND_DELETE="-exec rm \{\} \+"
20245     fi
20246     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20247 $as_echo "no" >&6; }
20248   else
20249     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
20250 $as_echo "yes" >&6; }
20251   fi
20252   rmdir $DELETEDIR
20253 
20254 
20255 
20256   # These tools might not be installed by default,
20257   # need hint on how to install them.
20258 
20259 
20260 
20261   # Publish this variable in the help.
20262 
20263 
20264   if [ -z "${UNZIP+x}" ]; then
20265     # The variable is not set by user, try to locate tool using the code snippet
20266     for ac_prog in unzip
20267 do
20268   # Extract the first word of "$ac_prog", so it can be a program name with args.
20269 set dummy $ac_prog; ac_word=$2
20270 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
20271 $as_echo_n "checking for $ac_word... " >&6; }
20272 if ${ac_cv_path_UNZIP+:} false; then :
20273   $as_echo_n "(cached) " >&6
20274 else
20275   case $UNZIP in
20276   [\\/]* | ?:[\\/]*)
20277   ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
20278   ;;
20279   *)
20280   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
20281 for as_dir in $PATH
20282 do
20283   IFS=$as_save_IFS
20284   test -z "$as_dir" && as_dir=.
20285     for ac_exec_ext in '' $ac_executable_extensions; do
20286   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
20287     ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
20288     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
20289     break 2
20290   fi
20291 done
20292   done
20293 IFS=$as_save_IFS
20294 
20295   ;;
20296 esac
20297 fi
20298 UNZIP=$ac_cv_path_UNZIP
20299 if test -n "$UNZIP"; then
20300   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
20301 $as_echo "$UNZIP" >&6; }
20302 else
20303   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20304 $as_echo "no" >&6; }
20305 fi
20306 
20307 
20308   test -n "$UNZIP" && break
20309 done
20310 
20311   else
20312     # The variable is set, but is it from the command line or the environment?
20313 
20314     # Try to remove the string !UNZIP! from our list.
20315     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNZIP!/}
20316     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
20317       # If it failed, the variable was not from the command line. Ignore it,
20318       # but warn the user (except for BASH, which is always set by the calling BASH).
20319       if test "xUNZIP" != xBASH; then
20320         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNZIP from the environment. Use command line variables instead." >&5
20321 $as_echo "$as_me: WARNING: Ignoring value of UNZIP from the environment. Use command line variables instead." >&2;}
20322       fi
20323       # Try to locate tool using the code snippet
20324       for ac_prog in unzip
20325 do
20326   # Extract the first word of "$ac_prog", so it can be a program name with args.
20327 set dummy $ac_prog; ac_word=$2
20328 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
20329 $as_echo_n "checking for $ac_word... " >&6; }
20330 if ${ac_cv_path_UNZIP+:} false; then :
20331   $as_echo_n "(cached) " >&6
20332 else
20333   case $UNZIP in
20334   [\\/]* | ?:[\\/]*)
20335   ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
20336   ;;
20337   *)
20338   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
20339 for as_dir in $PATH
20340 do
20341   IFS=$as_save_IFS
20342   test -z "$as_dir" && as_dir=.
20343     for ac_exec_ext in '' $ac_executable_extensions; do
20344   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
20345     ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
20346     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
20347     break 2
20348   fi
20349 done
20350   done
20351 IFS=$as_save_IFS
20352 
20353   ;;
20354 esac
20355 fi
20356 UNZIP=$ac_cv_path_UNZIP
20357 if test -n "$UNZIP"; then
20358   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
20359 $as_echo "$UNZIP" >&6; }
20360 else
20361   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20362 $as_echo "no" >&6; }
20363 fi
20364 
20365 
20366   test -n "$UNZIP" && break
20367 done
20368 
20369     else
20370       # If it succeeded, then it was overridden by the user. We will use it
20371       # for the tool.
20372 
20373       # First remove it from the list of overridden variables, so we can test
20374       # for unknown variables in the end.
20375       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
20376 
20377       # Check if we try to supply an empty value
20378       if test "x$UNZIP" = x; then
20379         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool UNZIP= (no value)" >&5
20380 $as_echo "$as_me: Setting user supplied tool UNZIP= (no value)" >&6;}
20381         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNZIP" >&5
20382 $as_echo_n "checking for UNZIP... " >&6; }
20383         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
20384 $as_echo "disabled" >&6; }
20385       else
20386         # Check if the provided tool contains a complete path.
20387         tool_specified="$UNZIP"
20388         tool_basename="${tool_specified##*/}"
20389         if test "x$tool_basename" = "x$tool_specified"; then
20390           # A command without a complete path is provided, search $PATH.
20391           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNZIP=$tool_basename" >&5
20392 $as_echo "$as_me: Will search for user supplied tool UNZIP=$tool_basename" >&6;}
20393           # Extract the first word of "$tool_basename", so it can be a program name with args.
20394 set dummy $tool_basename; ac_word=$2
20395 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
20396 $as_echo_n "checking for $ac_word... " >&6; }
20397 if ${ac_cv_path_UNZIP+:} false; then :
20398   $as_echo_n "(cached) " >&6
20399 else
20400   case $UNZIP in
20401   [\\/]* | ?:[\\/]*)
20402   ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
20403   ;;
20404   *)
20405   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
20406 for as_dir in $PATH
20407 do
20408   IFS=$as_save_IFS
20409   test -z "$as_dir" && as_dir=.
20410     for ac_exec_ext in '' $ac_executable_extensions; do
20411   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
20412     ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
20413     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
20414     break 2
20415   fi
20416 done
20417   done
20418 IFS=$as_save_IFS
20419 
20420   ;;
20421 esac
20422 fi
20423 UNZIP=$ac_cv_path_UNZIP
20424 if test -n "$UNZIP"; then
20425   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
20426 $as_echo "$UNZIP" >&6; }
20427 else
20428   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20429 $as_echo "no" >&6; }
20430 fi
20431 
20432 
20433           if test "x$UNZIP" = x; then
20434             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
20435           fi
20436         else
20437           # Otherwise we believe it is a complete path. Use it as it is.
20438           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNZIP=$tool_specified" >&5
20439 $as_echo "$as_me: Will use user supplied tool UNZIP=$tool_specified" >&6;}
20440           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNZIP" >&5
20441 $as_echo_n "checking for UNZIP... " >&6; }
20442           if test ! -x "$tool_specified"; then
20443             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
20444 $as_echo "not found" >&6; }
20445             as_fn_error $? "User supplied tool UNZIP=$tool_specified does not exist or is not executable" "$LINENO" 5
20446           fi
20447           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
20448 $as_echo "$tool_specified" >&6; }
20449         fi
20450       fi
20451     fi
20452 
20453   fi
20454 
20455 
20456 
20457   if test "x$UNZIP" = x; then
20458     as_fn_error $? "Could not find required tool for UNZIP" "$LINENO" 5
20459   fi
20460 
20461 
20462 
20463 
20464 
20465   # Publish this variable in the help.
20466 
20467 
20468   if [ -z "${ZIP+x}" ]; then
20469     # The variable is not set by user, try to locate tool using the code snippet
20470     for ac_prog in zip
20471 do
20472   # Extract the first word of "$ac_prog", so it can be a program name with args.
20473 set dummy $ac_prog; ac_word=$2
20474 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
20475 $as_echo_n "checking for $ac_word... " >&6; }
20476 if ${ac_cv_path_ZIP+:} false; then :
20477   $as_echo_n "(cached) " >&6
20478 else
20479   case $ZIP in
20480   [\\/]* | ?:[\\/]*)
20481   ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
20482   ;;
20483   *)
20484   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
20485 for as_dir in $PATH
20486 do
20487   IFS=$as_save_IFS
20488   test -z "$as_dir" && as_dir=.
20489     for ac_exec_ext in '' $ac_executable_extensions; do
20490   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
20491     ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
20492     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
20493     break 2
20494   fi
20495 done
20496   done
20497 IFS=$as_save_IFS
20498 
20499   ;;
20500 esac
20501 fi
20502 ZIP=$ac_cv_path_ZIP
20503 if test -n "$ZIP"; then
20504   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
20505 $as_echo "$ZIP" >&6; }
20506 else
20507   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20508 $as_echo "no" >&6; }
20509 fi
20510 
20511 
20512   test -n "$ZIP" && break
20513 done
20514 
20515   else
20516     # The variable is set, but is it from the command line or the environment?
20517 
20518     # Try to remove the string !ZIP! from our list.
20519     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!ZIP!/}
20520     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
20521       # If it failed, the variable was not from the command line. Ignore it,
20522       # but warn the user (except for BASH, which is always set by the calling BASH).
20523       if test "xZIP" != xBASH; then
20524         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ZIP from the environment. Use command line variables instead." >&5
20525 $as_echo "$as_me: WARNING: Ignoring value of ZIP from the environment. Use command line variables instead." >&2;}
20526       fi
20527       # Try to locate tool using the code snippet
20528       for ac_prog in zip
20529 do
20530   # Extract the first word of "$ac_prog", so it can be a program name with args.
20531 set dummy $ac_prog; ac_word=$2
20532 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
20533 $as_echo_n "checking for $ac_word... " >&6; }
20534 if ${ac_cv_path_ZIP+:} false; then :
20535   $as_echo_n "(cached) " >&6
20536 else
20537   case $ZIP in
20538   [\\/]* | ?:[\\/]*)
20539   ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
20540   ;;
20541   *)
20542   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
20543 for as_dir in $PATH
20544 do
20545   IFS=$as_save_IFS
20546   test -z "$as_dir" && as_dir=.
20547     for ac_exec_ext in '' $ac_executable_extensions; do
20548   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
20549     ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
20550     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
20551     break 2
20552   fi
20553 done
20554   done
20555 IFS=$as_save_IFS
20556 
20557   ;;
20558 esac
20559 fi
20560 ZIP=$ac_cv_path_ZIP
20561 if test -n "$ZIP"; then
20562   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
20563 $as_echo "$ZIP" >&6; }
20564 else
20565   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20566 $as_echo "no" >&6; }
20567 fi
20568 
20569 
20570   test -n "$ZIP" && break
20571 done
20572 
20573     else
20574       # If it succeeded, then it was overridden by the user. We will use it
20575       # for the tool.
20576 
20577       # First remove it from the list of overridden variables, so we can test
20578       # for unknown variables in the end.
20579       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
20580 
20581       # Check if we try to supply an empty value
20582       if test "x$ZIP" = x; then
20583         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool ZIP= (no value)" >&5
20584 $as_echo "$as_me: Setting user supplied tool ZIP= (no value)" >&6;}
20585         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ZIP" >&5
20586 $as_echo_n "checking for ZIP... " >&6; }
20587         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
20588 $as_echo "disabled" >&6; }
20589       else
20590         # Check if the provided tool contains a complete path.
20591         tool_specified="$ZIP"
20592         tool_basename="${tool_specified##*/}"
20593         if test "x$tool_basename" = "x$tool_specified"; then
20594           # A command without a complete path is provided, search $PATH.
20595           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ZIP=$tool_basename" >&5
20596 $as_echo "$as_me: Will search for user supplied tool ZIP=$tool_basename" >&6;}
20597           # Extract the first word of "$tool_basename", so it can be a program name with args.
20598 set dummy $tool_basename; ac_word=$2
20599 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
20600 $as_echo_n "checking for $ac_word... " >&6; }
20601 if ${ac_cv_path_ZIP+:} false; then :
20602   $as_echo_n "(cached) " >&6
20603 else
20604   case $ZIP in
20605   [\\/]* | ?:[\\/]*)
20606   ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
20607   ;;
20608   *)
20609   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
20610 for as_dir in $PATH
20611 do
20612   IFS=$as_save_IFS
20613   test -z "$as_dir" && as_dir=.
20614     for ac_exec_ext in '' $ac_executable_extensions; do
20615   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
20616     ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
20617     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
20618     break 2
20619   fi
20620 done
20621   done
20622 IFS=$as_save_IFS
20623 
20624   ;;
20625 esac
20626 fi
20627 ZIP=$ac_cv_path_ZIP
20628 if test -n "$ZIP"; then
20629   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
20630 $as_echo "$ZIP" >&6; }
20631 else
20632   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20633 $as_echo "no" >&6; }
20634 fi
20635 
20636 
20637           if test "x$ZIP" = x; then
20638             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
20639           fi
20640         else
20641           # Otherwise we believe it is a complete path. Use it as it is.
20642           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ZIP=$tool_specified" >&5
20643 $as_echo "$as_me: Will use user supplied tool ZIP=$tool_specified" >&6;}
20644           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ZIP" >&5
20645 $as_echo_n "checking for ZIP... " >&6; }
20646           if test ! -x "$tool_specified"; then
20647             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
20648 $as_echo "not found" >&6; }
20649             as_fn_error $? "User supplied tool ZIP=$tool_specified does not exist or is not executable" "$LINENO" 5
20650           fi
20651           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
20652 $as_echo "$tool_specified" >&6; }
20653         fi
20654       fi
20655     fi
20656 
20657   fi
20658 
20659 
20660 
20661   if test "x$ZIP" = x; then
20662     as_fn_error $? "Could not find required tool for ZIP" "$LINENO" 5
20663   fi
20664 
20665 
20666 
20667   # Non-required basic tools
20668 
20669 
20670 
20671   # Publish this variable in the help.
20672 
20673 
20674   if [ -z "${LDD+x}" ]; then
20675     # The variable is not set by user, try to locate tool using the code snippet
20676     for ac_prog in ldd
20677 do
20678   # Extract the first word of "$ac_prog", so it can be a program name with args.
20679 set dummy $ac_prog; ac_word=$2
20680 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
20681 $as_echo_n "checking for $ac_word... " >&6; }
20682 if ${ac_cv_path_LDD+:} false; then :
20683   $as_echo_n "(cached) " >&6
20684 else
20685   case $LDD in
20686   [\\/]* | ?:[\\/]*)
20687   ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
20688   ;;
20689   *)
20690   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
20691 for as_dir in $PATH
20692 do
20693   IFS=$as_save_IFS
20694   test -z "$as_dir" && as_dir=.
20695     for ac_exec_ext in '' $ac_executable_extensions; do
20696   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
20697     ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
20698     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
20699     break 2
20700   fi
20701 done
20702   done
20703 IFS=$as_save_IFS
20704 
20705   ;;
20706 esac
20707 fi
20708 LDD=$ac_cv_path_LDD
20709 if test -n "$LDD"; then
20710   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
20711 $as_echo "$LDD" >&6; }
20712 else
20713   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20714 $as_echo "no" >&6; }
20715 fi
20716 
20717 
20718   test -n "$LDD" && break
20719 done
20720 
20721   else
20722     # The variable is set, but is it from the command line or the environment?
20723 
20724     # Try to remove the string !LDD! from our list.
20725     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LDD!/}
20726     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
20727       # If it failed, the variable was not from the command line. Ignore it,
20728       # but warn the user (except for BASH, which is always set by the calling BASH).
20729       if test "xLDD" != xBASH; then
20730         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LDD from the environment. Use command line variables instead." >&5
20731 $as_echo "$as_me: WARNING: Ignoring value of LDD from the environment. Use command line variables instead." >&2;}
20732       fi
20733       # Try to locate tool using the code snippet
20734       for ac_prog in ldd
20735 do
20736   # Extract the first word of "$ac_prog", so it can be a program name with args.
20737 set dummy $ac_prog; ac_word=$2
20738 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
20739 $as_echo_n "checking for $ac_word... " >&6; }
20740 if ${ac_cv_path_LDD+:} false; then :
20741   $as_echo_n "(cached) " >&6
20742 else
20743   case $LDD in
20744   [\\/]* | ?:[\\/]*)
20745   ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
20746   ;;
20747   *)
20748   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
20749 for as_dir in $PATH
20750 do
20751   IFS=$as_save_IFS
20752   test -z "$as_dir" && as_dir=.
20753     for ac_exec_ext in '' $ac_executable_extensions; do
20754   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
20755     ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
20756     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
20757     break 2
20758   fi
20759 done
20760   done
20761 IFS=$as_save_IFS
20762 
20763   ;;
20764 esac
20765 fi
20766 LDD=$ac_cv_path_LDD
20767 if test -n "$LDD"; then
20768   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
20769 $as_echo "$LDD" >&6; }
20770 else
20771   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20772 $as_echo "no" >&6; }
20773 fi
20774 
20775 
20776   test -n "$LDD" && break
20777 done
20778 
20779     else
20780       # If it succeeded, then it was overridden by the user. We will use it
20781       # for the tool.
20782 
20783       # First remove it from the list of overridden variables, so we can test
20784       # for unknown variables in the end.
20785       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
20786 
20787       # Check if we try to supply an empty value
20788       if test "x$LDD" = x; then
20789         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool LDD= (no value)" >&5
20790 $as_echo "$as_me: Setting user supplied tool LDD= (no value)" >&6;}
20791         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LDD" >&5
20792 $as_echo_n "checking for LDD... " >&6; }
20793         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
20794 $as_echo "disabled" >&6; }
20795       else
20796         # Check if the provided tool contains a complete path.
20797         tool_specified="$LDD"
20798         tool_basename="${tool_specified##*/}"
20799         if test "x$tool_basename" = "x$tool_specified"; then
20800           # A command without a complete path is provided, search $PATH.
20801           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LDD=$tool_basename" >&5
20802 $as_echo "$as_me: Will search for user supplied tool LDD=$tool_basename" >&6;}
20803           # Extract the first word of "$tool_basename", so it can be a program name with args.
20804 set dummy $tool_basename; ac_word=$2
20805 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
20806 $as_echo_n "checking for $ac_word... " >&6; }
20807 if ${ac_cv_path_LDD+:} false; then :
20808   $as_echo_n "(cached) " >&6
20809 else
20810   case $LDD in
20811   [\\/]* | ?:[\\/]*)
20812   ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
20813   ;;
20814   *)
20815   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
20816 for as_dir in $PATH
20817 do
20818   IFS=$as_save_IFS
20819   test -z "$as_dir" && as_dir=.
20820     for ac_exec_ext in '' $ac_executable_extensions; do
20821   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
20822     ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
20823     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
20824     break 2
20825   fi
20826 done
20827   done
20828 IFS=$as_save_IFS
20829 
20830   ;;
20831 esac
20832 fi
20833 LDD=$ac_cv_path_LDD
20834 if test -n "$LDD"; then
20835   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
20836 $as_echo "$LDD" >&6; }
20837 else
20838   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20839 $as_echo "no" >&6; }
20840 fi
20841 
20842 
20843           if test "x$LDD" = x; then
20844             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
20845           fi
20846         else
20847           # Otherwise we believe it is a complete path. Use it as it is.
20848           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LDD=$tool_specified" >&5
20849 $as_echo "$as_me: Will use user supplied tool LDD=$tool_specified" >&6;}
20850           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LDD" >&5
20851 $as_echo_n "checking for LDD... " >&6; }
20852           if test ! -x "$tool_specified"; then
20853             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
20854 $as_echo "not found" >&6; }
20855             as_fn_error $? "User supplied tool LDD=$tool_specified does not exist or is not executable" "$LINENO" 5
20856           fi
20857           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
20858 $as_echo "$tool_specified" >&6; }
20859         fi
20860       fi
20861     fi
20862 
20863   fi
20864 
20865 
20866   if test "x$LDD" = "x"; then
20867     # List shared lib dependencies is used for
20868     # debug output and checking for forbidden dependencies.
20869     # We can build without it.
20870     LDD="true"
20871   fi
20872 
20873 
20874   # Publish this variable in the help.
20875 
20876 
20877   if [ -z "${OTOOL+x}" ]; then
20878     # The variable is not set by user, try to locate tool using the code snippet
20879     for ac_prog in otool
20880 do
20881   # Extract the first word of "$ac_prog", so it can be a program name with args.
20882 set dummy $ac_prog; ac_word=$2
20883 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
20884 $as_echo_n "checking for $ac_word... " >&6; }
20885 if ${ac_cv_path_OTOOL+:} false; then :
20886   $as_echo_n "(cached) " >&6
20887 else
20888   case $OTOOL in
20889   [\\/]* | ?:[\\/]*)
20890   ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
20891   ;;
20892   *)
20893   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
20894 for as_dir in $PATH
20895 do
20896   IFS=$as_save_IFS
20897   test -z "$as_dir" && as_dir=.
20898     for ac_exec_ext in '' $ac_executable_extensions; do
20899   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
20900     ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
20901     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
20902     break 2
20903   fi
20904 done
20905   done
20906 IFS=$as_save_IFS
20907 
20908   ;;
20909 esac
20910 fi
20911 OTOOL=$ac_cv_path_OTOOL
20912 if test -n "$OTOOL"; then
20913   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
20914 $as_echo "$OTOOL" >&6; }
20915 else
20916   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20917 $as_echo "no" >&6; }
20918 fi
20919 
20920 
20921   test -n "$OTOOL" && break
20922 done
20923 
20924   else
20925     # The variable is set, but is it from the command line or the environment?
20926 
20927     # Try to remove the string !OTOOL! from our list.
20928     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!OTOOL!/}
20929     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
20930       # If it failed, the variable was not from the command line. Ignore it,
20931       # but warn the user (except for BASH, which is always set by the calling BASH).
20932       if test "xOTOOL" != xBASH; then
20933         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of OTOOL from the environment. Use command line variables instead." >&5
20934 $as_echo "$as_me: WARNING: Ignoring value of OTOOL from the environment. Use command line variables instead." >&2;}
20935       fi
20936       # Try to locate tool using the code snippet
20937       for ac_prog in otool
20938 do
20939   # Extract the first word of "$ac_prog", so it can be a program name with args.
20940 set dummy $ac_prog; ac_word=$2
20941 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
20942 $as_echo_n "checking for $ac_word... " >&6; }
20943 if ${ac_cv_path_OTOOL+:} false; then :
20944   $as_echo_n "(cached) " >&6
20945 else
20946   case $OTOOL in
20947   [\\/]* | ?:[\\/]*)
20948   ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
20949   ;;
20950   *)
20951   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
20952 for as_dir in $PATH
20953 do
20954   IFS=$as_save_IFS
20955   test -z "$as_dir" && as_dir=.
20956     for ac_exec_ext in '' $ac_executable_extensions; do
20957   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
20958     ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
20959     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
20960     break 2
20961   fi
20962 done
20963   done
20964 IFS=$as_save_IFS
20965 
20966   ;;
20967 esac
20968 fi
20969 OTOOL=$ac_cv_path_OTOOL
20970 if test -n "$OTOOL"; then
20971   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
20972 $as_echo "$OTOOL" >&6; }
20973 else
20974   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20975 $as_echo "no" >&6; }
20976 fi
20977 
20978 
20979   test -n "$OTOOL" && break
20980 done
20981 
20982     else
20983       # If it succeeded, then it was overridden by the user. We will use it
20984       # for the tool.
20985 
20986       # First remove it from the list of overridden variables, so we can test
20987       # for unknown variables in the end.
20988       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
20989 
20990       # Check if we try to supply an empty value
20991       if test "x$OTOOL" = x; then
20992         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool OTOOL= (no value)" >&5
20993 $as_echo "$as_me: Setting user supplied tool OTOOL= (no value)" >&6;}
20994         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for OTOOL" >&5
20995 $as_echo_n "checking for OTOOL... " >&6; }
20996         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
20997 $as_echo "disabled" >&6; }
20998       else
20999         # Check if the provided tool contains a complete path.
21000         tool_specified="$OTOOL"
21001         tool_basename="${tool_specified##*/}"
21002         if test "x$tool_basename" = "x$tool_specified"; then
21003           # A command without a complete path is provided, search $PATH.
21004           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool OTOOL=$tool_basename" >&5
21005 $as_echo "$as_me: Will search for user supplied tool OTOOL=$tool_basename" >&6;}
21006           # Extract the first word of "$tool_basename", so it can be a program name with args.
21007 set dummy $tool_basename; ac_word=$2
21008 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21009 $as_echo_n "checking for $ac_word... " >&6; }
21010 if ${ac_cv_path_OTOOL+:} false; then :
21011   $as_echo_n "(cached) " >&6
21012 else
21013   case $OTOOL in
21014   [\\/]* | ?:[\\/]*)
21015   ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
21016   ;;
21017   *)
21018   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21019 for as_dir in $PATH
21020 do
21021   IFS=$as_save_IFS
21022   test -z "$as_dir" && as_dir=.
21023     for ac_exec_ext in '' $ac_executable_extensions; do
21024   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21025     ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
21026     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21027     break 2
21028   fi
21029 done
21030   done
21031 IFS=$as_save_IFS
21032 
21033   ;;
21034 esac
21035 fi
21036 OTOOL=$ac_cv_path_OTOOL
21037 if test -n "$OTOOL"; then
21038   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
21039 $as_echo "$OTOOL" >&6; }
21040 else
21041   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21042 $as_echo "no" >&6; }
21043 fi
21044 
21045 
21046           if test "x$OTOOL" = x; then
21047             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
21048           fi
21049         else
21050           # Otherwise we believe it is a complete path. Use it as it is.
21051           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool OTOOL=$tool_specified" >&5
21052 $as_echo "$as_me: Will use user supplied tool OTOOL=$tool_specified" >&6;}
21053           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for OTOOL" >&5
21054 $as_echo_n "checking for OTOOL... " >&6; }
21055           if test ! -x "$tool_specified"; then
21056             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
21057 $as_echo "not found" >&6; }
21058             as_fn_error $? "User supplied tool OTOOL=$tool_specified does not exist or is not executable" "$LINENO" 5
21059           fi
21060           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
21061 $as_echo "$tool_specified" >&6; }
21062         fi
21063       fi
21064     fi
21065 
21066   fi
21067 
21068 
21069   if test "x$OTOOL" = "x"; then
21070     OTOOL="true"
21071   fi
21072 
21073 
21074   # Publish this variable in the help.
21075 
21076 
21077   if [ -z "${READELF+x}" ]; then
21078     # The variable is not set by user, try to locate tool using the code snippet
21079     for ac_prog in greadelf readelf
21080 do
21081   # Extract the first word of "$ac_prog", so it can be a program name with args.
21082 set dummy $ac_prog; ac_word=$2
21083 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21084 $as_echo_n "checking for $ac_word... " >&6; }
21085 if ${ac_cv_path_READELF+:} false; then :
21086   $as_echo_n "(cached) " >&6
21087 else
21088   case $READELF in
21089   [\\/]* | ?:[\\/]*)
21090   ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
21091   ;;
21092   *)
21093   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21094 for as_dir in $PATH
21095 do
21096   IFS=$as_save_IFS
21097   test -z "$as_dir" && as_dir=.
21098     for ac_exec_ext in '' $ac_executable_extensions; do
21099   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21100     ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
21101     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21102     break 2
21103   fi
21104 done
21105   done
21106 IFS=$as_save_IFS
21107 
21108   ;;
21109 esac
21110 fi
21111 READELF=$ac_cv_path_READELF
21112 if test -n "$READELF"; then
21113   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
21114 $as_echo "$READELF" >&6; }
21115 else
21116   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21117 $as_echo "no" >&6; }
21118 fi
21119 
21120 
21121   test -n "$READELF" && break
21122 done
21123 
21124   else
21125     # The variable is set, but is it from the command line or the environment?
21126 
21127     # Try to remove the string !READELF! from our list.
21128     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!READELF!/}
21129     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
21130       # If it failed, the variable was not from the command line. Ignore it,
21131       # but warn the user (except for BASH, which is always set by the calling BASH).
21132       if test "xREADELF" != xBASH; then
21133         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of READELF from the environment. Use command line variables instead." >&5
21134 $as_echo "$as_me: WARNING: Ignoring value of READELF from the environment. Use command line variables instead." >&2;}
21135       fi
21136       # Try to locate tool using the code snippet
21137       for ac_prog in greadelf readelf
21138 do
21139   # Extract the first word of "$ac_prog", so it can be a program name with args.
21140 set dummy $ac_prog; ac_word=$2
21141 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21142 $as_echo_n "checking for $ac_word... " >&6; }
21143 if ${ac_cv_path_READELF+:} false; then :
21144   $as_echo_n "(cached) " >&6
21145 else
21146   case $READELF in
21147   [\\/]* | ?:[\\/]*)
21148   ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
21149   ;;
21150   *)
21151   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21152 for as_dir in $PATH
21153 do
21154   IFS=$as_save_IFS
21155   test -z "$as_dir" && as_dir=.
21156     for ac_exec_ext in '' $ac_executable_extensions; do
21157   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21158     ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
21159     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21160     break 2
21161   fi
21162 done
21163   done
21164 IFS=$as_save_IFS
21165 
21166   ;;
21167 esac
21168 fi
21169 READELF=$ac_cv_path_READELF
21170 if test -n "$READELF"; then
21171   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
21172 $as_echo "$READELF" >&6; }
21173 else
21174   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21175 $as_echo "no" >&6; }
21176 fi
21177 
21178 
21179   test -n "$READELF" && break
21180 done
21181 
21182     else
21183       # If it succeeded, then it was overridden by the user. We will use it
21184       # for the tool.
21185 
21186       # First remove it from the list of overridden variables, so we can test
21187       # for unknown variables in the end.
21188       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
21189 
21190       # Check if we try to supply an empty value
21191       if test "x$READELF" = x; then
21192         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool READELF= (no value)" >&5
21193 $as_echo "$as_me: Setting user supplied tool READELF= (no value)" >&6;}
21194         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READELF" >&5
21195 $as_echo_n "checking for READELF... " >&6; }
21196         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
21197 $as_echo "disabled" >&6; }
21198       else
21199         # Check if the provided tool contains a complete path.
21200         tool_specified="$READELF"
21201         tool_basename="${tool_specified##*/}"
21202         if test "x$tool_basename" = "x$tool_specified"; then
21203           # A command without a complete path is provided, search $PATH.
21204           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool READELF=$tool_basename" >&5
21205 $as_echo "$as_me: Will search for user supplied tool READELF=$tool_basename" >&6;}
21206           # Extract the first word of "$tool_basename", so it can be a program name with args.
21207 set dummy $tool_basename; ac_word=$2
21208 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21209 $as_echo_n "checking for $ac_word... " >&6; }
21210 if ${ac_cv_path_READELF+:} false; then :
21211   $as_echo_n "(cached) " >&6
21212 else
21213   case $READELF in
21214   [\\/]* | ?:[\\/]*)
21215   ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
21216   ;;
21217   *)
21218   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21219 for as_dir in $PATH
21220 do
21221   IFS=$as_save_IFS
21222   test -z "$as_dir" && as_dir=.
21223     for ac_exec_ext in '' $ac_executable_extensions; do
21224   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21225     ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
21226     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21227     break 2
21228   fi
21229 done
21230   done
21231 IFS=$as_save_IFS
21232 
21233   ;;
21234 esac
21235 fi
21236 READELF=$ac_cv_path_READELF
21237 if test -n "$READELF"; then
21238   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
21239 $as_echo "$READELF" >&6; }
21240 else
21241   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21242 $as_echo "no" >&6; }
21243 fi
21244 
21245 
21246           if test "x$READELF" = x; then
21247             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
21248           fi
21249         else
21250           # Otherwise we believe it is a complete path. Use it as it is.
21251           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool READELF=$tool_specified" >&5
21252 $as_echo "$as_me: Will use user supplied tool READELF=$tool_specified" >&6;}
21253           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READELF" >&5
21254 $as_echo_n "checking for READELF... " >&6; }
21255           if test ! -x "$tool_specified"; then
21256             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
21257 $as_echo "not found" >&6; }
21258             as_fn_error $? "User supplied tool READELF=$tool_specified does not exist or is not executable" "$LINENO" 5
21259           fi
21260           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
21261 $as_echo "$tool_specified" >&6; }
21262         fi
21263       fi
21264     fi
21265 
21266   fi
21267 
21268 
21269 
21270 
21271   # Publish this variable in the help.
21272 
21273 
21274   if [ -z "${HG+x}" ]; then
21275     # The variable is not set by user, try to locate tool using the code snippet
21276     for ac_prog in hg
21277 do
21278   # Extract the first word of "$ac_prog", so it can be a program name with args.
21279 set dummy $ac_prog; ac_word=$2
21280 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21281 $as_echo_n "checking for $ac_word... " >&6; }
21282 if ${ac_cv_path_HG+:} false; then :
21283   $as_echo_n "(cached) " >&6
21284 else
21285   case $HG in
21286   [\\/]* | ?:[\\/]*)
21287   ac_cv_path_HG="$HG" # Let the user override the test with a path.
21288   ;;
21289   *)
21290   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21291 for as_dir in $PATH
21292 do
21293   IFS=$as_save_IFS
21294   test -z "$as_dir" && as_dir=.
21295     for ac_exec_ext in '' $ac_executable_extensions; do
21296   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21297     ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
21298     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21299     break 2
21300   fi
21301 done
21302   done
21303 IFS=$as_save_IFS
21304 
21305   ;;
21306 esac
21307 fi
21308 HG=$ac_cv_path_HG
21309 if test -n "$HG"; then
21310   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
21311 $as_echo "$HG" >&6; }
21312 else
21313   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21314 $as_echo "no" >&6; }
21315 fi
21316 
21317 
21318   test -n "$HG" && break
21319 done
21320 
21321   else
21322     # The variable is set, but is it from the command line or the environment?
21323 
21324     # Try to remove the string !HG! from our list.
21325     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!HG!/}
21326     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
21327       # If it failed, the variable was not from the command line. Ignore it,
21328       # but warn the user (except for BASH, which is always set by the calling BASH).
21329       if test "xHG" != xBASH; then
21330         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of HG from the environment. Use command line variables instead." >&5
21331 $as_echo "$as_me: WARNING: Ignoring value of HG from the environment. Use command line variables instead." >&2;}
21332       fi
21333       # Try to locate tool using the code snippet
21334       for ac_prog in hg
21335 do
21336   # Extract the first word of "$ac_prog", so it can be a program name with args.
21337 set dummy $ac_prog; ac_word=$2
21338 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21339 $as_echo_n "checking for $ac_word... " >&6; }
21340 if ${ac_cv_path_HG+:} false; then :
21341   $as_echo_n "(cached) " >&6
21342 else
21343   case $HG in
21344   [\\/]* | ?:[\\/]*)
21345   ac_cv_path_HG="$HG" # Let the user override the test with a path.
21346   ;;
21347   *)
21348   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21349 for as_dir in $PATH
21350 do
21351   IFS=$as_save_IFS
21352   test -z "$as_dir" && as_dir=.
21353     for ac_exec_ext in '' $ac_executable_extensions; do
21354   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21355     ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
21356     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21357     break 2
21358   fi
21359 done
21360   done
21361 IFS=$as_save_IFS
21362 
21363   ;;
21364 esac
21365 fi
21366 HG=$ac_cv_path_HG
21367 if test -n "$HG"; then
21368   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
21369 $as_echo "$HG" >&6; }
21370 else
21371   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21372 $as_echo "no" >&6; }
21373 fi
21374 
21375 
21376   test -n "$HG" && break
21377 done
21378 
21379     else
21380       # If it succeeded, then it was overridden by the user. We will use it
21381       # for the tool.
21382 
21383       # First remove it from the list of overridden variables, so we can test
21384       # for unknown variables in the end.
21385       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
21386 
21387       # Check if we try to supply an empty value
21388       if test "x$HG" = x; then
21389         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool HG= (no value)" >&5
21390 $as_echo "$as_me: Setting user supplied tool HG= (no value)" >&6;}
21391         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HG" >&5
21392 $as_echo_n "checking for HG... " >&6; }
21393         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
21394 $as_echo "disabled" >&6; }
21395       else
21396         # Check if the provided tool contains a complete path.
21397         tool_specified="$HG"
21398         tool_basename="${tool_specified##*/}"
21399         if test "x$tool_basename" = "x$tool_specified"; then
21400           # A command without a complete path is provided, search $PATH.
21401           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool HG=$tool_basename" >&5
21402 $as_echo "$as_me: Will search for user supplied tool HG=$tool_basename" >&6;}
21403           # Extract the first word of "$tool_basename", so it can be a program name with args.
21404 set dummy $tool_basename; ac_word=$2
21405 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21406 $as_echo_n "checking for $ac_word... " >&6; }
21407 if ${ac_cv_path_HG+:} false; then :
21408   $as_echo_n "(cached) " >&6
21409 else
21410   case $HG in
21411   [\\/]* | ?:[\\/]*)
21412   ac_cv_path_HG="$HG" # Let the user override the test with a path.
21413   ;;
21414   *)
21415   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21416 for as_dir in $PATH
21417 do
21418   IFS=$as_save_IFS
21419   test -z "$as_dir" && as_dir=.
21420     for ac_exec_ext in '' $ac_executable_extensions; do
21421   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21422     ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
21423     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21424     break 2
21425   fi
21426 done
21427   done
21428 IFS=$as_save_IFS
21429 
21430   ;;
21431 esac
21432 fi
21433 HG=$ac_cv_path_HG
21434 if test -n "$HG"; then
21435   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
21436 $as_echo "$HG" >&6; }
21437 else
21438   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21439 $as_echo "no" >&6; }
21440 fi
21441 
21442 
21443           if test "x$HG" = x; then
21444             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
21445           fi
21446         else
21447           # Otherwise we believe it is a complete path. Use it as it is.
21448           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool HG=$tool_specified" >&5
21449 $as_echo "$as_me: Will use user supplied tool HG=$tool_specified" >&6;}
21450           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HG" >&5
21451 $as_echo_n "checking for HG... " >&6; }
21452           if test ! -x "$tool_specified"; then
21453             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
21454 $as_echo "not found" >&6; }
21455             as_fn_error $? "User supplied tool HG=$tool_specified does not exist or is not executable" "$LINENO" 5
21456           fi
21457           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
21458 $as_echo "$tool_specified" >&6; }
21459         fi
21460       fi
21461     fi
21462 
21463   fi
21464 
21465 
21466 
21467 
21468   # Publish this variable in the help.
21469 
21470 
21471   if [ -z "${STAT+x}" ]; then
21472     # The variable is not set by user, try to locate tool using the code snippet
21473     for ac_prog in stat
21474 do
21475   # Extract the first word of "$ac_prog", so it can be a program name with args.
21476 set dummy $ac_prog; ac_word=$2
21477 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21478 $as_echo_n "checking for $ac_word... " >&6; }
21479 if ${ac_cv_path_STAT+:} false; then :
21480   $as_echo_n "(cached) " >&6
21481 else
21482   case $STAT in
21483   [\\/]* | ?:[\\/]*)
21484   ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
21485   ;;
21486   *)
21487   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21488 for as_dir in $PATH
21489 do
21490   IFS=$as_save_IFS
21491   test -z "$as_dir" && as_dir=.
21492     for ac_exec_ext in '' $ac_executable_extensions; do
21493   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21494     ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
21495     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21496     break 2
21497   fi
21498 done
21499   done
21500 IFS=$as_save_IFS
21501 
21502   ;;
21503 esac
21504 fi
21505 STAT=$ac_cv_path_STAT
21506 if test -n "$STAT"; then
21507   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
21508 $as_echo "$STAT" >&6; }
21509 else
21510   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21511 $as_echo "no" >&6; }
21512 fi
21513 
21514 
21515   test -n "$STAT" && break
21516 done
21517 
21518   else
21519     # The variable is set, but is it from the command line or the environment?
21520 
21521     # Try to remove the string !STAT! from our list.
21522     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!STAT!/}
21523     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
21524       # If it failed, the variable was not from the command line. Ignore it,
21525       # but warn the user (except for BASH, which is always set by the calling BASH).
21526       if test "xSTAT" != xBASH; then
21527         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of STAT from the environment. Use command line variables instead." >&5
21528 $as_echo "$as_me: WARNING: Ignoring value of STAT from the environment. Use command line variables instead." >&2;}
21529       fi
21530       # Try to locate tool using the code snippet
21531       for ac_prog in stat
21532 do
21533   # Extract the first word of "$ac_prog", so it can be a program name with args.
21534 set dummy $ac_prog; ac_word=$2
21535 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21536 $as_echo_n "checking for $ac_word... " >&6; }
21537 if ${ac_cv_path_STAT+:} false; then :
21538   $as_echo_n "(cached) " >&6
21539 else
21540   case $STAT in
21541   [\\/]* | ?:[\\/]*)
21542   ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
21543   ;;
21544   *)
21545   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21546 for as_dir in $PATH
21547 do
21548   IFS=$as_save_IFS
21549   test -z "$as_dir" && as_dir=.
21550     for ac_exec_ext in '' $ac_executable_extensions; do
21551   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21552     ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
21553     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21554     break 2
21555   fi
21556 done
21557   done
21558 IFS=$as_save_IFS
21559 
21560   ;;
21561 esac
21562 fi
21563 STAT=$ac_cv_path_STAT
21564 if test -n "$STAT"; then
21565   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
21566 $as_echo "$STAT" >&6; }
21567 else
21568   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21569 $as_echo "no" >&6; }
21570 fi
21571 
21572 
21573   test -n "$STAT" && break
21574 done
21575 
21576     else
21577       # If it succeeded, then it was overridden by the user. We will use it
21578       # for the tool.
21579 
21580       # First remove it from the list of overridden variables, so we can test
21581       # for unknown variables in the end.
21582       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
21583 
21584       # Check if we try to supply an empty value
21585       if test "x$STAT" = x; then
21586         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool STAT= (no value)" >&5
21587 $as_echo "$as_me: Setting user supplied tool STAT= (no value)" >&6;}
21588         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for STAT" >&5
21589 $as_echo_n "checking for STAT... " >&6; }
21590         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
21591 $as_echo "disabled" >&6; }
21592       else
21593         # Check if the provided tool contains a complete path.
21594         tool_specified="$STAT"
21595         tool_basename="${tool_specified##*/}"
21596         if test "x$tool_basename" = "x$tool_specified"; then
21597           # A command without a complete path is provided, search $PATH.
21598           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool STAT=$tool_basename" >&5
21599 $as_echo "$as_me: Will search for user supplied tool STAT=$tool_basename" >&6;}
21600           # Extract the first word of "$tool_basename", so it can be a program name with args.
21601 set dummy $tool_basename; ac_word=$2
21602 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21603 $as_echo_n "checking for $ac_word... " >&6; }
21604 if ${ac_cv_path_STAT+:} false; then :
21605   $as_echo_n "(cached) " >&6
21606 else
21607   case $STAT in
21608   [\\/]* | ?:[\\/]*)
21609   ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
21610   ;;
21611   *)
21612   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21613 for as_dir in $PATH
21614 do
21615   IFS=$as_save_IFS
21616   test -z "$as_dir" && as_dir=.
21617     for ac_exec_ext in '' $ac_executable_extensions; do
21618   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21619     ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
21620     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21621     break 2
21622   fi
21623 done
21624   done
21625 IFS=$as_save_IFS
21626 
21627   ;;
21628 esac
21629 fi
21630 STAT=$ac_cv_path_STAT
21631 if test -n "$STAT"; then
21632   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
21633 $as_echo "$STAT" >&6; }
21634 else
21635   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21636 $as_echo "no" >&6; }
21637 fi
21638 
21639 
21640           if test "x$STAT" = x; then
21641             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
21642           fi
21643         else
21644           # Otherwise we believe it is a complete path. Use it as it is.
21645           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool STAT=$tool_specified" >&5
21646 $as_echo "$as_me: Will use user supplied tool STAT=$tool_specified" >&6;}
21647           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for STAT" >&5
21648 $as_echo_n "checking for STAT... " >&6; }
21649           if test ! -x "$tool_specified"; then
21650             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
21651 $as_echo "not found" >&6; }
21652             as_fn_error $? "User supplied tool STAT=$tool_specified does not exist or is not executable" "$LINENO" 5
21653           fi
21654           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
21655 $as_echo "$tool_specified" >&6; }
21656         fi
21657       fi
21658     fi
21659 
21660   fi
21661 
21662 
21663 
21664 
21665   # Publish this variable in the help.
21666 
21667 
21668   if [ -z "${TIME+x}" ]; then
21669     # The variable is not set by user, try to locate tool using the code snippet
21670     for ac_prog in time
21671 do
21672   # Extract the first word of "$ac_prog", so it can be a program name with args.
21673 set dummy $ac_prog; ac_word=$2
21674 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21675 $as_echo_n "checking for $ac_word... " >&6; }
21676 if ${ac_cv_path_TIME+:} false; then :
21677   $as_echo_n "(cached) " >&6
21678 else
21679   case $TIME in
21680   [\\/]* | ?:[\\/]*)
21681   ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
21682   ;;
21683   *)
21684   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21685 for as_dir in $PATH
21686 do
21687   IFS=$as_save_IFS
21688   test -z "$as_dir" && as_dir=.
21689     for ac_exec_ext in '' $ac_executable_extensions; do
21690   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21691     ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
21692     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21693     break 2
21694   fi
21695 done
21696   done
21697 IFS=$as_save_IFS
21698 
21699   ;;
21700 esac
21701 fi
21702 TIME=$ac_cv_path_TIME
21703 if test -n "$TIME"; then
21704   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
21705 $as_echo "$TIME" >&6; }
21706 else
21707   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21708 $as_echo "no" >&6; }
21709 fi
21710 
21711 
21712   test -n "$TIME" && break
21713 done
21714 
21715   else
21716     # The variable is set, but is it from the command line or the environment?
21717 
21718     # Try to remove the string !TIME! from our list.
21719     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TIME!/}
21720     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
21721       # If it failed, the variable was not from the command line. Ignore it,
21722       # but warn the user (except for BASH, which is always set by the calling BASH).
21723       if test "xTIME" != xBASH; then
21724         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TIME from the environment. Use command line variables instead." >&5
21725 $as_echo "$as_me: WARNING: Ignoring value of TIME from the environment. Use command line variables instead." >&2;}
21726       fi
21727       # Try to locate tool using the code snippet
21728       for ac_prog in time
21729 do
21730   # Extract the first word of "$ac_prog", so it can be a program name with args.
21731 set dummy $ac_prog; ac_word=$2
21732 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21733 $as_echo_n "checking for $ac_word... " >&6; }
21734 if ${ac_cv_path_TIME+:} false; then :
21735   $as_echo_n "(cached) " >&6
21736 else
21737   case $TIME in
21738   [\\/]* | ?:[\\/]*)
21739   ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
21740   ;;
21741   *)
21742   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21743 for as_dir in $PATH
21744 do
21745   IFS=$as_save_IFS
21746   test -z "$as_dir" && as_dir=.
21747     for ac_exec_ext in '' $ac_executable_extensions; do
21748   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21749     ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
21750     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21751     break 2
21752   fi
21753 done
21754   done
21755 IFS=$as_save_IFS
21756 
21757   ;;
21758 esac
21759 fi
21760 TIME=$ac_cv_path_TIME
21761 if test -n "$TIME"; then
21762   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
21763 $as_echo "$TIME" >&6; }
21764 else
21765   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21766 $as_echo "no" >&6; }
21767 fi
21768 
21769 
21770   test -n "$TIME" && break
21771 done
21772 
21773     else
21774       # If it succeeded, then it was overridden by the user. We will use it
21775       # for the tool.
21776 
21777       # First remove it from the list of overridden variables, so we can test
21778       # for unknown variables in the end.
21779       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
21780 
21781       # Check if we try to supply an empty value
21782       if test "x$TIME" = x; then
21783         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool TIME= (no value)" >&5
21784 $as_echo "$as_me: Setting user supplied tool TIME= (no value)" >&6;}
21785         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TIME" >&5
21786 $as_echo_n "checking for TIME... " >&6; }
21787         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
21788 $as_echo "disabled" >&6; }
21789       else
21790         # Check if the provided tool contains a complete path.
21791         tool_specified="$TIME"
21792         tool_basename="${tool_specified##*/}"
21793         if test "x$tool_basename" = "x$tool_specified"; then
21794           # A command without a complete path is provided, search $PATH.
21795           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TIME=$tool_basename" >&5
21796 $as_echo "$as_me: Will search for user supplied tool TIME=$tool_basename" >&6;}
21797           # Extract the first word of "$tool_basename", so it can be a program name with args.
21798 set dummy $tool_basename; ac_word=$2
21799 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21800 $as_echo_n "checking for $ac_word... " >&6; }
21801 if ${ac_cv_path_TIME+:} false; then :
21802   $as_echo_n "(cached) " >&6
21803 else
21804   case $TIME in
21805   [\\/]* | ?:[\\/]*)
21806   ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
21807   ;;
21808   *)
21809   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21810 for as_dir in $PATH
21811 do
21812   IFS=$as_save_IFS
21813   test -z "$as_dir" && as_dir=.
21814     for ac_exec_ext in '' $ac_executable_extensions; do
21815   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21816     ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
21817     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21818     break 2
21819   fi
21820 done
21821   done
21822 IFS=$as_save_IFS
21823 
21824   ;;
21825 esac
21826 fi
21827 TIME=$ac_cv_path_TIME
21828 if test -n "$TIME"; then
21829   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
21830 $as_echo "$TIME" >&6; }
21831 else
21832   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21833 $as_echo "no" >&6; }
21834 fi
21835 
21836 
21837           if test "x$TIME" = x; then
21838             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
21839           fi
21840         else
21841           # Otherwise we believe it is a complete path. Use it as it is.
21842           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TIME=$tool_specified" >&5
21843 $as_echo "$as_me: Will use user supplied tool TIME=$tool_specified" >&6;}
21844           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TIME" >&5
21845 $as_echo_n "checking for TIME... " >&6; }
21846           if test ! -x "$tool_specified"; then
21847             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
21848 $as_echo "not found" >&6; }
21849             as_fn_error $? "User supplied tool TIME=$tool_specified does not exist or is not executable" "$LINENO" 5
21850           fi
21851           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
21852 $as_echo "$tool_specified" >&6; }
21853         fi
21854       fi
21855     fi
21856 
21857   fi
21858 
21859 
21860 
21861 
21862   # Publish this variable in the help.
21863 
21864 
21865   if [ -z "${PATCH+x}" ]; then
21866     # The variable is not set by user, try to locate tool using the code snippet
21867     for ac_prog in gpatch patch
21868 do
21869   # Extract the first word of "$ac_prog", so it can be a program name with args.
21870 set dummy $ac_prog; ac_word=$2
21871 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21872 $as_echo_n "checking for $ac_word... " >&6; }
21873 if ${ac_cv_path_PATCH+:} false; then :
21874   $as_echo_n "(cached) " >&6
21875 else
21876   case $PATCH in
21877   [\\/]* | ?:[\\/]*)
21878   ac_cv_path_PATCH="$PATCH" # Let the user override the test with a path.
21879   ;;
21880   *)
21881   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21882 for as_dir in $PATH
21883 do
21884   IFS=$as_save_IFS
21885   test -z "$as_dir" && as_dir=.
21886     for ac_exec_ext in '' $ac_executable_extensions; do
21887   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21888     ac_cv_path_PATCH="$as_dir/$ac_word$ac_exec_ext"
21889     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21890     break 2
21891   fi
21892 done
21893   done
21894 IFS=$as_save_IFS
21895 
21896   ;;
21897 esac
21898 fi
21899 PATCH=$ac_cv_path_PATCH
21900 if test -n "$PATCH"; then
21901   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PATCH" >&5
21902 $as_echo "$PATCH" >&6; }
21903 else
21904   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21905 $as_echo "no" >&6; }
21906 fi
21907 
21908 
21909   test -n "$PATCH" && break
21910 done
21911 
21912   else
21913     # The variable is set, but is it from the command line or the environment?
21914 
21915     # Try to remove the string !PATCH! from our list.
21916     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!PATCH!/}
21917     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
21918       # If it failed, the variable was not from the command line. Ignore it,
21919       # but warn the user (except for BASH, which is always set by the calling BASH).
21920       if test "xPATCH" != xBASH; then
21921         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of PATCH from the environment. Use command line variables instead." >&5
21922 $as_echo "$as_me: WARNING: Ignoring value of PATCH from the environment. Use command line variables instead." >&2;}
21923       fi
21924       # Try to locate tool using the code snippet
21925       for ac_prog in gpatch patch
21926 do
21927   # Extract the first word of "$ac_prog", so it can be a program name with args.
21928 set dummy $ac_prog; ac_word=$2
21929 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21930 $as_echo_n "checking for $ac_word... " >&6; }
21931 if ${ac_cv_path_PATCH+:} false; then :
21932   $as_echo_n "(cached) " >&6
21933 else
21934   case $PATCH in
21935   [\\/]* | ?:[\\/]*)
21936   ac_cv_path_PATCH="$PATCH" # Let the user override the test with a path.
21937   ;;
21938   *)
21939   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21940 for as_dir in $PATH
21941 do
21942   IFS=$as_save_IFS
21943   test -z "$as_dir" && as_dir=.
21944     for ac_exec_ext in '' $ac_executable_extensions; do
21945   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21946     ac_cv_path_PATCH="$as_dir/$ac_word$ac_exec_ext"
21947     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21948     break 2
21949   fi
21950 done
21951   done
21952 IFS=$as_save_IFS
21953 
21954   ;;
21955 esac
21956 fi
21957 PATCH=$ac_cv_path_PATCH
21958 if test -n "$PATCH"; then
21959   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PATCH" >&5
21960 $as_echo "$PATCH" >&6; }
21961 else
21962   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21963 $as_echo "no" >&6; }
21964 fi
21965 
21966 
21967   test -n "$PATCH" && break
21968 done
21969 
21970     else
21971       # If it succeeded, then it was overridden by the user. We will use it
21972       # for the tool.
21973 
21974       # First remove it from the list of overridden variables, so we can test
21975       # for unknown variables in the end.
21976       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
21977 
21978       # Check if we try to supply an empty value
21979       if test "x$PATCH" = x; then
21980         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool PATCH= (no value)" >&5
21981 $as_echo "$as_me: Setting user supplied tool PATCH= (no value)" >&6;}
21982         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PATCH" >&5
21983 $as_echo_n "checking for PATCH... " >&6; }
21984         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
21985 $as_echo "disabled" >&6; }
21986       else
21987         # Check if the provided tool contains a complete path.
21988         tool_specified="$PATCH"
21989         tool_basename="${tool_specified##*/}"
21990         if test "x$tool_basename" = "x$tool_specified"; then
21991           # A command without a complete path is provided, search $PATH.
21992           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool PATCH=$tool_basename" >&5
21993 $as_echo "$as_me: Will search for user supplied tool PATCH=$tool_basename" >&6;}
21994           # Extract the first word of "$tool_basename", so it can be a program name with args.
21995 set dummy $tool_basename; ac_word=$2
21996 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21997 $as_echo_n "checking for $ac_word... " >&6; }
21998 if ${ac_cv_path_PATCH+:} false; then :
21999   $as_echo_n "(cached) " >&6
22000 else
22001   case $PATCH in
22002   [\\/]* | ?:[\\/]*)
22003   ac_cv_path_PATCH="$PATCH" # Let the user override the test with a path.
22004   ;;
22005   *)
22006   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22007 for as_dir in $PATH
22008 do
22009   IFS=$as_save_IFS
22010   test -z "$as_dir" && as_dir=.
22011     for ac_exec_ext in '' $ac_executable_extensions; do
22012   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22013     ac_cv_path_PATCH="$as_dir/$ac_word$ac_exec_ext"
22014     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22015     break 2
22016   fi
22017 done
22018   done
22019 IFS=$as_save_IFS
22020 
22021   ;;
22022 esac
22023 fi
22024 PATCH=$ac_cv_path_PATCH
22025 if test -n "$PATCH"; then
22026   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PATCH" >&5
22027 $as_echo "$PATCH" >&6; }
22028 else
22029   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22030 $as_echo "no" >&6; }
22031 fi
22032 
22033 
22034           if test "x$PATCH" = x; then
22035             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
22036           fi
22037         else
22038           # Otherwise we believe it is a complete path. Use it as it is.
22039           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool PATCH=$tool_specified" >&5
22040 $as_echo "$as_me: Will use user supplied tool PATCH=$tool_specified" >&6;}
22041           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PATCH" >&5
22042 $as_echo_n "checking for PATCH... " >&6; }
22043           if test ! -x "$tool_specified"; then
22044             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
22045 $as_echo "not found" >&6; }
22046             as_fn_error $? "User supplied tool PATCH=$tool_specified does not exist or is not executable" "$LINENO" 5
22047           fi
22048           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
22049 $as_echo "$tool_specified" >&6; }
22050         fi
22051       fi
22052     fi
22053 
22054   fi
22055 
22056 
22057   # Check if it's GNU time
22058   IS_GNU_TIME=`$TIME --version 2>&1 | $GREP 'GNU time'`
22059   if test "x$IS_GNU_TIME" != x; then
22060     IS_GNU_TIME=yes
22061   else
22062     IS_GNU_TIME=no
22063   fi
22064 
22065 
22066   if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
22067 
22068 
22069 
22070   # Publish this variable in the help.
22071 
22072 
22073   if [ -z "${DSYMUTIL+x}" ]; then
22074     # The variable is not set by user, try to locate tool using the code snippet
22075     for ac_prog in dsymutil
22076 do
22077   # Extract the first word of "$ac_prog", so it can be a program name with args.
22078 set dummy $ac_prog; ac_word=$2
22079 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22080 $as_echo_n "checking for $ac_word... " >&6; }
22081 if ${ac_cv_path_DSYMUTIL+:} false; then :
22082   $as_echo_n "(cached) " >&6
22083 else
22084   case $DSYMUTIL in
22085   [\\/]* | ?:[\\/]*)
22086   ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
22087   ;;
22088   *)
22089   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22090 for as_dir in $PATH
22091 do
22092   IFS=$as_save_IFS
22093   test -z "$as_dir" && as_dir=.
22094     for ac_exec_ext in '' $ac_executable_extensions; do
22095   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22096     ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
22097     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22098     break 2
22099   fi
22100 done
22101   done
22102 IFS=$as_save_IFS
22103 
22104   ;;
22105 esac
22106 fi
22107 DSYMUTIL=$ac_cv_path_DSYMUTIL
22108 if test -n "$DSYMUTIL"; then
22109   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
22110 $as_echo "$DSYMUTIL" >&6; }
22111 else
22112   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22113 $as_echo "no" >&6; }
22114 fi
22115 
22116 
22117   test -n "$DSYMUTIL" && break
22118 done
22119 
22120   else
22121     # The variable is set, but is it from the command line or the environment?
22122 
22123     # Try to remove the string !DSYMUTIL! from our list.
22124     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DSYMUTIL!/}
22125     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
22126       # If it failed, the variable was not from the command line. Ignore it,
22127       # but warn the user (except for BASH, which is always set by the calling BASH).
22128       if test "xDSYMUTIL" != xBASH; then
22129         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DSYMUTIL from the environment. Use command line variables instead." >&5
22130 $as_echo "$as_me: WARNING: Ignoring value of DSYMUTIL from the environment. Use command line variables instead." >&2;}
22131       fi
22132       # Try to locate tool using the code snippet
22133       for ac_prog in dsymutil
22134 do
22135   # Extract the first word of "$ac_prog", so it can be a program name with args.
22136 set dummy $ac_prog; ac_word=$2
22137 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22138 $as_echo_n "checking for $ac_word... " >&6; }
22139 if ${ac_cv_path_DSYMUTIL+:} false; then :
22140   $as_echo_n "(cached) " >&6
22141 else
22142   case $DSYMUTIL in
22143   [\\/]* | ?:[\\/]*)
22144   ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
22145   ;;
22146   *)
22147   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22148 for as_dir in $PATH
22149 do
22150   IFS=$as_save_IFS
22151   test -z "$as_dir" && as_dir=.
22152     for ac_exec_ext in '' $ac_executable_extensions; do
22153   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22154     ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
22155     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22156     break 2
22157   fi
22158 done
22159   done
22160 IFS=$as_save_IFS
22161 
22162   ;;
22163 esac
22164 fi
22165 DSYMUTIL=$ac_cv_path_DSYMUTIL
22166 if test -n "$DSYMUTIL"; then
22167   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
22168 $as_echo "$DSYMUTIL" >&6; }
22169 else
22170   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22171 $as_echo "no" >&6; }
22172 fi
22173 
22174 
22175   test -n "$DSYMUTIL" && break
22176 done
22177 
22178     else
22179       # If it succeeded, then it was overridden by the user. We will use it
22180       # for the tool.
22181 
22182       # First remove it from the list of overridden variables, so we can test
22183       # for unknown variables in the end.
22184       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
22185 
22186       # Check if we try to supply an empty value
22187       if test "x$DSYMUTIL" = x; then
22188         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool DSYMUTIL= (no value)" >&5
22189 $as_echo "$as_me: Setting user supplied tool DSYMUTIL= (no value)" >&6;}
22190         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DSYMUTIL" >&5
22191 $as_echo_n "checking for DSYMUTIL... " >&6; }
22192         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
22193 $as_echo "disabled" >&6; }
22194       else
22195         # Check if the provided tool contains a complete path.
22196         tool_specified="$DSYMUTIL"
22197         tool_basename="${tool_specified##*/}"
22198         if test "x$tool_basename" = "x$tool_specified"; then
22199           # A command without a complete path is provided, search $PATH.
22200           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DSYMUTIL=$tool_basename" >&5
22201 $as_echo "$as_me: Will search for user supplied tool DSYMUTIL=$tool_basename" >&6;}
22202           # Extract the first word of "$tool_basename", so it can be a program name with args.
22203 set dummy $tool_basename; ac_word=$2
22204 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22205 $as_echo_n "checking for $ac_word... " >&6; }
22206 if ${ac_cv_path_DSYMUTIL+:} false; then :
22207   $as_echo_n "(cached) " >&6
22208 else
22209   case $DSYMUTIL in
22210   [\\/]* | ?:[\\/]*)
22211   ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
22212   ;;
22213   *)
22214   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22215 for as_dir in $PATH
22216 do
22217   IFS=$as_save_IFS
22218   test -z "$as_dir" && as_dir=.
22219     for ac_exec_ext in '' $ac_executable_extensions; do
22220   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22221     ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
22222     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22223     break 2
22224   fi
22225 done
22226   done
22227 IFS=$as_save_IFS
22228 
22229   ;;
22230 esac
22231 fi
22232 DSYMUTIL=$ac_cv_path_DSYMUTIL
22233 if test -n "$DSYMUTIL"; then
22234   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
22235 $as_echo "$DSYMUTIL" >&6; }
22236 else
22237   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22238 $as_echo "no" >&6; }
22239 fi
22240 
22241 
22242           if test "x$DSYMUTIL" = x; then
22243             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
22244           fi
22245         else
22246           # Otherwise we believe it is a complete path. Use it as it is.
22247           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DSYMUTIL=$tool_specified" >&5
22248 $as_echo "$as_me: Will use user supplied tool DSYMUTIL=$tool_specified" >&6;}
22249           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DSYMUTIL" >&5
22250 $as_echo_n "checking for DSYMUTIL... " >&6; }
22251           if test ! -x "$tool_specified"; then
22252             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
22253 $as_echo "not found" >&6; }
22254             as_fn_error $? "User supplied tool DSYMUTIL=$tool_specified does not exist or is not executable" "$LINENO" 5
22255           fi
22256           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
22257 $as_echo "$tool_specified" >&6; }
22258         fi
22259       fi
22260     fi
22261 
22262   fi
22263 
22264 
22265 
22266   if test "x$DSYMUTIL" = x; then
22267     as_fn_error $? "Could not find required tool for DSYMUTIL" "$LINENO" 5
22268   fi
22269 
22270 
22271 
22272 
22273 
22274   # Publish this variable in the help.
22275 
22276 
22277   if [ -z "${XATTR+x}" ]; then
22278     # The variable is not set by user, try to locate tool using the code snippet
22279     for ac_prog in xattr
22280 do
22281   # Extract the first word of "$ac_prog", so it can be a program name with args.
22282 set dummy $ac_prog; ac_word=$2
22283 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22284 $as_echo_n "checking for $ac_word... " >&6; }
22285 if ${ac_cv_path_XATTR+:} false; then :
22286   $as_echo_n "(cached) " >&6
22287 else
22288   case $XATTR in
22289   [\\/]* | ?:[\\/]*)
22290   ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
22291   ;;
22292   *)
22293   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22294 for as_dir in $PATH
22295 do
22296   IFS=$as_save_IFS
22297   test -z "$as_dir" && as_dir=.
22298     for ac_exec_ext in '' $ac_executable_extensions; do
22299   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22300     ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
22301     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22302     break 2
22303   fi
22304 done
22305   done
22306 IFS=$as_save_IFS
22307 
22308   ;;
22309 esac
22310 fi
22311 XATTR=$ac_cv_path_XATTR
22312 if test -n "$XATTR"; then
22313   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
22314 $as_echo "$XATTR" >&6; }
22315 else
22316   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22317 $as_echo "no" >&6; }
22318 fi
22319 
22320 
22321   test -n "$XATTR" && break
22322 done
22323 
22324   else
22325     # The variable is set, but is it from the command line or the environment?
22326 
22327     # Try to remove the string !XATTR! from our list.
22328     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!XATTR!/}
22329     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
22330       # If it failed, the variable was not from the command line. Ignore it,
22331       # but warn the user (except for BASH, which is always set by the calling BASH).
22332       if test "xXATTR" != xBASH; then
22333         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of XATTR from the environment. Use command line variables instead." >&5
22334 $as_echo "$as_me: WARNING: Ignoring value of XATTR from the environment. Use command line variables instead." >&2;}
22335       fi
22336       # Try to locate tool using the code snippet
22337       for ac_prog in xattr
22338 do
22339   # Extract the first word of "$ac_prog", so it can be a program name with args.
22340 set dummy $ac_prog; ac_word=$2
22341 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22342 $as_echo_n "checking for $ac_word... " >&6; }
22343 if ${ac_cv_path_XATTR+:} false; then :
22344   $as_echo_n "(cached) " >&6
22345 else
22346   case $XATTR in
22347   [\\/]* | ?:[\\/]*)
22348   ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
22349   ;;
22350   *)
22351   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22352 for as_dir in $PATH
22353 do
22354   IFS=$as_save_IFS
22355   test -z "$as_dir" && as_dir=.
22356     for ac_exec_ext in '' $ac_executable_extensions; do
22357   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22358     ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
22359     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22360     break 2
22361   fi
22362 done
22363   done
22364 IFS=$as_save_IFS
22365 
22366   ;;
22367 esac
22368 fi
22369 XATTR=$ac_cv_path_XATTR
22370 if test -n "$XATTR"; then
22371   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
22372 $as_echo "$XATTR" >&6; }
22373 else
22374   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22375 $as_echo "no" >&6; }
22376 fi
22377 
22378 
22379   test -n "$XATTR" && break
22380 done
22381 
22382     else
22383       # If it succeeded, then it was overridden by the user. We will use it
22384       # for the tool.
22385 
22386       # First remove it from the list of overridden variables, so we can test
22387       # for unknown variables in the end.
22388       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
22389 
22390       # Check if we try to supply an empty value
22391       if test "x$XATTR" = x; then
22392         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool XATTR= (no value)" >&5
22393 $as_echo "$as_me: Setting user supplied tool XATTR= (no value)" >&6;}
22394         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XATTR" >&5
22395 $as_echo_n "checking for XATTR... " >&6; }
22396         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
22397 $as_echo "disabled" >&6; }
22398       else
22399         # Check if the provided tool contains a complete path.
22400         tool_specified="$XATTR"
22401         tool_basename="${tool_specified##*/}"
22402         if test "x$tool_basename" = "x$tool_specified"; then
22403           # A command without a complete path is provided, search $PATH.
22404           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool XATTR=$tool_basename" >&5
22405 $as_echo "$as_me: Will search for user supplied tool XATTR=$tool_basename" >&6;}
22406           # Extract the first word of "$tool_basename", so it can be a program name with args.
22407 set dummy $tool_basename; ac_word=$2
22408 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22409 $as_echo_n "checking for $ac_word... " >&6; }
22410 if ${ac_cv_path_XATTR+:} false; then :
22411   $as_echo_n "(cached) " >&6
22412 else
22413   case $XATTR in
22414   [\\/]* | ?:[\\/]*)
22415   ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
22416   ;;
22417   *)
22418   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22419 for as_dir in $PATH
22420 do
22421   IFS=$as_save_IFS
22422   test -z "$as_dir" && as_dir=.
22423     for ac_exec_ext in '' $ac_executable_extensions; do
22424   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22425     ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
22426     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22427     break 2
22428   fi
22429 done
22430   done
22431 IFS=$as_save_IFS
22432 
22433   ;;
22434 esac
22435 fi
22436 XATTR=$ac_cv_path_XATTR
22437 if test -n "$XATTR"; then
22438   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
22439 $as_echo "$XATTR" >&6; }
22440 else
22441   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22442 $as_echo "no" >&6; }
22443 fi
22444 
22445 
22446           if test "x$XATTR" = x; then
22447             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
22448           fi
22449         else
22450           # Otherwise we believe it is a complete path. Use it as it is.
22451           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool XATTR=$tool_specified" >&5
22452 $as_echo "$as_me: Will use user supplied tool XATTR=$tool_specified" >&6;}
22453           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XATTR" >&5
22454 $as_echo_n "checking for XATTR... " >&6; }
22455           if test ! -x "$tool_specified"; then
22456             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
22457 $as_echo "not found" >&6; }
22458             as_fn_error $? "User supplied tool XATTR=$tool_specified does not exist or is not executable" "$LINENO" 5
22459           fi
22460           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
22461 $as_echo "$tool_specified" >&6; }
22462         fi
22463       fi
22464     fi
22465 
22466   fi
22467 
22468 
22469 
22470   if test "x$XATTR" = x; then
22471     as_fn_error $? "Could not find required tool for XATTR" "$LINENO" 5
22472   fi
22473 
22474 
22475 
22476 
22477   # Publish this variable in the help.
22478 
22479 
22480   if [ -z "${CODESIGN+x}" ]; then
22481     # The variable is not set by user, try to locate tool using the code snippet
22482     for ac_prog in codesign
22483 do
22484   # Extract the first word of "$ac_prog", so it can be a program name with args.
22485 set dummy $ac_prog; ac_word=$2
22486 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22487 $as_echo_n "checking for $ac_word... " >&6; }
22488 if ${ac_cv_path_CODESIGN+:} false; then :
22489   $as_echo_n "(cached) " >&6
22490 else
22491   case $CODESIGN in
22492   [\\/]* | ?:[\\/]*)
22493   ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
22494   ;;
22495   *)
22496   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22497 for as_dir in $PATH
22498 do
22499   IFS=$as_save_IFS
22500   test -z "$as_dir" && as_dir=.
22501     for ac_exec_ext in '' $ac_executable_extensions; do
22502   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22503     ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
22504     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22505     break 2
22506   fi
22507 done
22508   done
22509 IFS=$as_save_IFS
22510 
22511   ;;
22512 esac
22513 fi
22514 CODESIGN=$ac_cv_path_CODESIGN
22515 if test -n "$CODESIGN"; then
22516   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
22517 $as_echo "$CODESIGN" >&6; }
22518 else
22519   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22520 $as_echo "no" >&6; }
22521 fi
22522 
22523 
22524   test -n "$CODESIGN" && break
22525 done
22526 
22527   else
22528     # The variable is set, but is it from the command line or the environment?
22529 
22530     # Try to remove the string !CODESIGN! from our list.
22531     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CODESIGN!/}
22532     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
22533       # If it failed, the variable was not from the command line. Ignore it,
22534       # but warn the user (except for BASH, which is always set by the calling BASH).
22535       if test "xCODESIGN" != xBASH; then
22536         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CODESIGN from the environment. Use command line variables instead." >&5
22537 $as_echo "$as_me: WARNING: Ignoring value of CODESIGN from the environment. Use command line variables instead." >&2;}
22538       fi
22539       # Try to locate tool using the code snippet
22540       for ac_prog in codesign
22541 do
22542   # Extract the first word of "$ac_prog", so it can be a program name with args.
22543 set dummy $ac_prog; ac_word=$2
22544 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22545 $as_echo_n "checking for $ac_word... " >&6; }
22546 if ${ac_cv_path_CODESIGN+:} false; then :
22547   $as_echo_n "(cached) " >&6
22548 else
22549   case $CODESIGN in
22550   [\\/]* | ?:[\\/]*)
22551   ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
22552   ;;
22553   *)
22554   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22555 for as_dir in $PATH
22556 do
22557   IFS=$as_save_IFS
22558   test -z "$as_dir" && as_dir=.
22559     for ac_exec_ext in '' $ac_executable_extensions; do
22560   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22561     ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
22562     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22563     break 2
22564   fi
22565 done
22566   done
22567 IFS=$as_save_IFS
22568 
22569   ;;
22570 esac
22571 fi
22572 CODESIGN=$ac_cv_path_CODESIGN
22573 if test -n "$CODESIGN"; then
22574   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
22575 $as_echo "$CODESIGN" >&6; }
22576 else
22577   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22578 $as_echo "no" >&6; }
22579 fi
22580 
22581 
22582   test -n "$CODESIGN" && break
22583 done
22584 
22585     else
22586       # If it succeeded, then it was overridden by the user. We will use it
22587       # for the tool.
22588 
22589       # First remove it from the list of overridden variables, so we can test
22590       # for unknown variables in the end.
22591       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
22592 
22593       # Check if we try to supply an empty value
22594       if test "x$CODESIGN" = x; then
22595         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CODESIGN= (no value)" >&5
22596 $as_echo "$as_me: Setting user supplied tool CODESIGN= (no value)" >&6;}
22597         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CODESIGN" >&5
22598 $as_echo_n "checking for CODESIGN... " >&6; }
22599         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
22600 $as_echo "disabled" >&6; }
22601       else
22602         # Check if the provided tool contains a complete path.
22603         tool_specified="$CODESIGN"
22604         tool_basename="${tool_specified##*/}"
22605         if test "x$tool_basename" = "x$tool_specified"; then
22606           # A command without a complete path is provided, search $PATH.
22607           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CODESIGN=$tool_basename" >&5
22608 $as_echo "$as_me: Will search for user supplied tool CODESIGN=$tool_basename" >&6;}
22609           # Extract the first word of "$tool_basename", so it can be a program name with args.
22610 set dummy $tool_basename; ac_word=$2
22611 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22612 $as_echo_n "checking for $ac_word... " >&6; }
22613 if ${ac_cv_path_CODESIGN+:} false; then :
22614   $as_echo_n "(cached) " >&6
22615 else
22616   case $CODESIGN in
22617   [\\/]* | ?:[\\/]*)
22618   ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
22619   ;;
22620   *)
22621   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22622 for as_dir in $PATH
22623 do
22624   IFS=$as_save_IFS
22625   test -z "$as_dir" && as_dir=.
22626     for ac_exec_ext in '' $ac_executable_extensions; do
22627   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22628     ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
22629     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22630     break 2
22631   fi
22632 done
22633   done
22634 IFS=$as_save_IFS
22635 
22636   ;;
22637 esac
22638 fi
22639 CODESIGN=$ac_cv_path_CODESIGN
22640 if test -n "$CODESIGN"; then
22641   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
22642 $as_echo "$CODESIGN" >&6; }
22643 else
22644   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22645 $as_echo "no" >&6; }
22646 fi
22647 
22648 
22649           if test "x$CODESIGN" = x; then
22650             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
22651           fi
22652         else
22653           # Otherwise we believe it is a complete path. Use it as it is.
22654           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CODESIGN=$tool_specified" >&5
22655 $as_echo "$as_me: Will use user supplied tool CODESIGN=$tool_specified" >&6;}
22656           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CODESIGN" >&5
22657 $as_echo_n "checking for CODESIGN... " >&6; }
22658           if test ! -x "$tool_specified"; then
22659             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
22660 $as_echo "not found" >&6; }
22661             as_fn_error $? "User supplied tool CODESIGN=$tool_specified does not exist or is not executable" "$LINENO" 5
22662           fi
22663           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
22664 $as_echo "$tool_specified" >&6; }
22665         fi
22666       fi
22667     fi
22668 
22669   fi
22670 
22671 
22672     if test "x$CODESIGN" != "x"; then
22673       # Verify that the openjdk_codesign certificate is present
22674       { $as_echo "$as_me:${as_lineno-$LINENO}: checking if openjdk_codesign certificate is present" >&5
22675 $as_echo_n "checking if openjdk_codesign certificate is present... " >&6; }
22676       rm -f codesign-testfile
22677       touch codesign-testfile
22678       codesign -s openjdk_codesign codesign-testfile 2>&5 >&5 || CODESIGN=
22679       rm -f codesign-testfile
22680       if test "x$CODESIGN" = x; then
22681         { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22682 $as_echo "no" >&6; }
22683       else
22684         { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
22685 $as_echo "yes" >&6; }
22686       fi
22687     fi
22688 
22689 
22690 
22691   # Publish this variable in the help.
22692 
22693 
22694   if [ -z "${SETFILE+x}" ]; then
22695     # The variable is not set by user, try to locate tool using the code snippet
22696     for ac_prog in SetFile
22697 do
22698   # Extract the first word of "$ac_prog", so it can be a program name with args.
22699 set dummy $ac_prog; ac_word=$2
22700 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22701 $as_echo_n "checking for $ac_word... " >&6; }
22702 if ${ac_cv_path_SETFILE+:} false; then :
22703   $as_echo_n "(cached) " >&6
22704 else
22705   case $SETFILE in
22706   [\\/]* | ?:[\\/]*)
22707   ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
22708   ;;
22709   *)
22710   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22711 for as_dir in $PATH
22712 do
22713   IFS=$as_save_IFS
22714   test -z "$as_dir" && as_dir=.
22715     for ac_exec_ext in '' $ac_executable_extensions; do
22716   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22717     ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
22718     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22719     break 2
22720   fi
22721 done
22722   done
22723 IFS=$as_save_IFS
22724 
22725   ;;
22726 esac
22727 fi
22728 SETFILE=$ac_cv_path_SETFILE
22729 if test -n "$SETFILE"; then
22730   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
22731 $as_echo "$SETFILE" >&6; }
22732 else
22733   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22734 $as_echo "no" >&6; }
22735 fi
22736 
22737 
22738   test -n "$SETFILE" && break
22739 done
22740 
22741   else
22742     # The variable is set, but is it from the command line or the environment?
22743 
22744     # Try to remove the string !SETFILE! from our list.
22745     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SETFILE!/}
22746     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
22747       # If it failed, the variable was not from the command line. Ignore it,
22748       # but warn the user (except for BASH, which is always set by the calling BASH).
22749       if test "xSETFILE" != xBASH; then
22750         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SETFILE from the environment. Use command line variables instead." >&5
22751 $as_echo "$as_me: WARNING: Ignoring value of SETFILE from the environment. Use command line variables instead." >&2;}
22752       fi
22753       # Try to locate tool using the code snippet
22754       for ac_prog in SetFile
22755 do
22756   # Extract the first word of "$ac_prog", so it can be a program name with args.
22757 set dummy $ac_prog; ac_word=$2
22758 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22759 $as_echo_n "checking for $ac_word... " >&6; }
22760 if ${ac_cv_path_SETFILE+:} false; then :
22761   $as_echo_n "(cached) " >&6
22762 else
22763   case $SETFILE in
22764   [\\/]* | ?:[\\/]*)
22765   ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
22766   ;;
22767   *)
22768   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22769 for as_dir in $PATH
22770 do
22771   IFS=$as_save_IFS
22772   test -z "$as_dir" && as_dir=.
22773     for ac_exec_ext in '' $ac_executable_extensions; do
22774   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22775     ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
22776     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22777     break 2
22778   fi
22779 done
22780   done
22781 IFS=$as_save_IFS
22782 
22783   ;;
22784 esac
22785 fi
22786 SETFILE=$ac_cv_path_SETFILE
22787 if test -n "$SETFILE"; then
22788   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
22789 $as_echo "$SETFILE" >&6; }
22790 else
22791   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22792 $as_echo "no" >&6; }
22793 fi
22794 
22795 
22796   test -n "$SETFILE" && break
22797 done
22798 
22799     else
22800       # If it succeeded, then it was overridden by the user. We will use it
22801       # for the tool.
22802 
22803       # First remove it from the list of overridden variables, so we can test
22804       # for unknown variables in the end.
22805       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
22806 
22807       # Check if we try to supply an empty value
22808       if test "x$SETFILE" = x; then
22809         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool SETFILE= (no value)" >&5
22810 $as_echo "$as_me: Setting user supplied tool SETFILE= (no value)" >&6;}
22811         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SETFILE" >&5
22812 $as_echo_n "checking for SETFILE... " >&6; }
22813         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
22814 $as_echo "disabled" >&6; }
22815       else
22816         # Check if the provided tool contains a complete path.
22817         tool_specified="$SETFILE"
22818         tool_basename="${tool_specified##*/}"
22819         if test "x$tool_basename" = "x$tool_specified"; then
22820           # A command without a complete path is provided, search $PATH.
22821           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SETFILE=$tool_basename" >&5
22822 $as_echo "$as_me: Will search for user supplied tool SETFILE=$tool_basename" >&6;}
22823           # Extract the first word of "$tool_basename", so it can be a program name with args.
22824 set dummy $tool_basename; ac_word=$2
22825 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22826 $as_echo_n "checking for $ac_word... " >&6; }
22827 if ${ac_cv_path_SETFILE+:} false; then :
22828   $as_echo_n "(cached) " >&6
22829 else
22830   case $SETFILE in
22831   [\\/]* | ?:[\\/]*)
22832   ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
22833   ;;
22834   *)
22835   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22836 for as_dir in $PATH
22837 do
22838   IFS=$as_save_IFS
22839   test -z "$as_dir" && as_dir=.
22840     for ac_exec_ext in '' $ac_executable_extensions; do
22841   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22842     ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
22843     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22844     break 2
22845   fi
22846 done
22847   done
22848 IFS=$as_save_IFS
22849 
22850   ;;
22851 esac
22852 fi
22853 SETFILE=$ac_cv_path_SETFILE
22854 if test -n "$SETFILE"; then
22855   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
22856 $as_echo "$SETFILE" >&6; }
22857 else
22858   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22859 $as_echo "no" >&6; }
22860 fi
22861 
22862 
22863           if test "x$SETFILE" = x; then
22864             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
22865           fi
22866         else
22867           # Otherwise we believe it is a complete path. Use it as it is.
22868           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SETFILE=$tool_specified" >&5
22869 $as_echo "$as_me: Will use user supplied tool SETFILE=$tool_specified" >&6;}
22870           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SETFILE" >&5
22871 $as_echo_n "checking for SETFILE... " >&6; }
22872           if test ! -x "$tool_specified"; then
22873             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
22874 $as_echo "not found" >&6; }
22875             as_fn_error $? "User supplied tool SETFILE=$tool_specified does not exist or is not executable" "$LINENO" 5
22876           fi
22877           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
22878 $as_echo "$tool_specified" >&6; }
22879         fi
22880       fi
22881     fi
22882 
22883   fi
22884 
22885 
22886 
22887   if test "x$SETFILE" = x; then
22888     as_fn_error $? "Could not find required tool for SETFILE" "$LINENO" 5
22889   fi
22890 
22891 
22892   fi
22893 
22894 
22895   # Test if bash supports pipefail.
22896   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if bash supports pipefail" >&5
22897 $as_echo_n "checking if bash supports pipefail... " >&6; }
22898   if ${BASH} -c 'set -o pipefail'; then
22899     BASH_ARGS="$BASH_ARGS -o pipefail"
22900     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
22901 $as_echo "yes" >&6; }
22902   else
22903     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22904 $as_echo "no" >&6; }
22905   fi
22906 
22907   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if bash supports errexit (-e)" >&5
22908 $as_echo_n "checking if bash supports errexit (-e)... " >&6; }
22909   if ${BASH} -e -c 'true'; then
22910     BASH_ARGS="$BASH_ARGS -e"
22911     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
22912 $as_echo "yes" >&6; }
22913   else
22914     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22915 $as_echo "no" >&6; }
22916   fi
22917 
22918 
22919 
22920 
22921 # Check if pkg-config is available.
22922 
22923 
22924 if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then
22925         if test -n "$ac_tool_prefix"; then
22926   # Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args.
22927 set dummy ${ac_tool_prefix}pkg-config; ac_word=$2
22928 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22929 $as_echo_n "checking for $ac_word... " >&6; }
22930 if ${ac_cv_path_PKG_CONFIG+:} false; then :
22931   $as_echo_n "(cached) " >&6
22932 else
22933   case $PKG_CONFIG in
22934   [\\/]* | ?:[\\/]*)
22935   ac_cv_path_PKG_CONFIG="$PKG_CONFIG" # Let the user override the test with a path.
22936   ;;
22937   *)
22938   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22939 for as_dir in $PATH
22940 do
22941   IFS=$as_save_IFS
22942   test -z "$as_dir" && as_dir=.
22943     for ac_exec_ext in '' $ac_executable_extensions; do
22944   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22945     ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
22946     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22947     break 2
22948   fi
22949 done
22950   done
22951 IFS=$as_save_IFS
22952 
22953   ;;
22954 esac
22955 fi
22956 PKG_CONFIG=$ac_cv_path_PKG_CONFIG
22957 if test -n "$PKG_CONFIG"; then
22958   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
22959 $as_echo "$PKG_CONFIG" >&6; }
22960 else
22961   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22962 $as_echo "no" >&6; }
22963 fi
22964 
22965 
22966 fi
22967 if test -z "$ac_cv_path_PKG_CONFIG"; then
22968   ac_pt_PKG_CONFIG=$PKG_CONFIG
22969   # Extract the first word of "pkg-config", so it can be a program name with args.
22970 set dummy pkg-config; ac_word=$2
22971 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22972 $as_echo_n "checking for $ac_word... " >&6; }
22973 if ${ac_cv_path_ac_pt_PKG_CONFIG+:} false; then :
22974   $as_echo_n "(cached) " >&6
22975 else
22976   case $ac_pt_PKG_CONFIG in
22977   [\\/]* | ?:[\\/]*)
22978   ac_cv_path_ac_pt_PKG_CONFIG="$ac_pt_PKG_CONFIG" # Let the user override the test with a path.
22979   ;;
22980   *)
22981   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22982 for as_dir in $PATH
22983 do
22984   IFS=$as_save_IFS
22985   test -z "$as_dir" && as_dir=.
22986     for ac_exec_ext in '' $ac_executable_extensions; do
22987   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22988     ac_cv_path_ac_pt_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
22989     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22990     break 2
22991   fi
22992 done
22993   done
22994 IFS=$as_save_IFS
22995 
22996   ;;
22997 esac
22998 fi
22999 ac_pt_PKG_CONFIG=$ac_cv_path_ac_pt_PKG_CONFIG
23000 if test -n "$ac_pt_PKG_CONFIG"; then
23001   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_pt_PKG_CONFIG" >&5
23002 $as_echo "$ac_pt_PKG_CONFIG" >&6; }
23003 else
23004   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23005 $as_echo "no" >&6; }
23006 fi
23007 
23008   if test "x$ac_pt_PKG_CONFIG" = x; then
23009     PKG_CONFIG=""
23010   else
23011     case $cross_compiling:$ac_tool_warned in
23012 yes:)
23013 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
23014 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
23015 ac_tool_warned=yes ;;
23016 esac
23017     PKG_CONFIG=$ac_pt_PKG_CONFIG
23018   fi
23019 else
23020   PKG_CONFIG="$ac_cv_path_PKG_CONFIG"
23021 fi
23022 
23023 fi
23024 if test -n "$PKG_CONFIG"; then
23025         _pkg_min_version=0.9.0
23026         { $as_echo "$as_me:${as_lineno-$LINENO}: checking pkg-config is at least version $_pkg_min_version" >&5
23027 $as_echo_n "checking pkg-config is at least version $_pkg_min_version... " >&6; }
23028         if $PKG_CONFIG --atleast-pkgconfig-version $_pkg_min_version; then
23029                 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
23030 $as_echo "yes" >&6; }
23031         else
23032                 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23033 $as_echo "no" >&6; }
23034                 PKG_CONFIG=""
23035         fi
23036 
23037 fi
23038 
23039 # After basic tools have been setup, we can check build os specific details.
23040 
23041   ###############################################################################
23042 
23043   # Note that this is the build platform OS version!
23044 
23045   OS_VERSION="`uname -r | ${SED} 's!\.! !g' | ${SED} 's!-! !g'`"
23046   OS_VERSION_MAJOR="`${ECHO} ${OS_VERSION} | ${CUT} -f 1 -d ' '`"
23047   OS_VERSION_MINOR="`${ECHO} ${OS_VERSION} | ${CUT} -f 2 -d ' '`"
23048   OS_VERSION_MICRO="`${ECHO} ${OS_VERSION} | ${CUT} -f 3 -d ' '`"
23049 
23050 
23051 
23052 
23053 
23054 ###############################################################################
23055 #
23056 # Determine OpenJDK variants, options and version numbers.
23057 #
23058 ###############################################################################
23059 
23060 # We need build & target for this.
23061 
23062 
23063   ###############################################################################
23064   #
23065   # Should we build a JDK/JVM with headful support (ie a graphical ui)?
23066   # We always build headless support.
23067   #
23068   { $as_echo "$as_me:${as_lineno-$LINENO}: checking headful support" >&5
23069 $as_echo_n "checking headful support... " >&6; }
23070   # Check whether --enable-headful was given.
23071 if test "${enable_headful+set}" = set; then :
23072   enableval=$enable_headful; SUPPORT_HEADFUL=${enable_headful}
23073 else
23074   SUPPORT_HEADFUL=yes
23075 fi
23076 
23077 
23078   SUPPORT_HEADLESS=yes
23079   BUILD_HEADLESS="BUILD_HEADLESS:=true"
23080 
23081   if test "x$SUPPORT_HEADFUL" = xyes; then
23082     # We are building both headful and headless.
23083     headful_msg="include support for both headful and headless"
23084   fi
23085 
23086   if test "x$SUPPORT_HEADFUL" = xno; then
23087     # Thus we are building headless only.
23088     BUILD_HEADLESS="BUILD_HEADLESS:=true"
23089     headful_msg="headless only"
23090   fi
23091 
23092   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $headful_msg" >&5
23093 $as_echo "$headful_msg" >&6; }
23094 
23095 
23096 
23097 
23098 
23099   # Control wether Hotspot runs Queens test after build.
23100   # Check whether --enable-hotspot-test-in-build was given.
23101 if test "${enable_hotspot_test_in_build+set}" = set; then :
23102   enableval=$enable_hotspot_test_in_build;
23103 else
23104   enable_hotspot_test_in_build=no
23105 fi
23106 
23107   if test "x$enable_hotspot_test_in_build" = "xyes"; then
23108     TEST_IN_BUILD=true
23109   else
23110     TEST_IN_BUILD=false
23111   fi
23112 
23113 
23114   ###############################################################################
23115   #
23116   # Choose cacerts source file
23117   #
23118 
23119 # Check whether --with-cacerts-file was given.
23120 if test "${with_cacerts_file+set}" = set; then :
23121   withval=$with_cacerts_file;
23122 fi
23123 
23124   if test "x$with_cacerts_file" != x; then
23125     CACERTS_FILE=$with_cacerts_file
23126   fi
23127 
23128 
23129   ###############################################################################
23130   #
23131   # Enable or disable unlimited crypto
23132   #
23133   # Check whether --enable-unlimited-crypto was given.
23134 if test "${enable_unlimited_crypto+set}" = set; then :
23135   enableval=$enable_unlimited_crypto;
23136 else
23137   enable_unlimited_crypto=no
23138 fi
23139 
23140   if test "x$enable_unlimited_crypto" = "xyes"; then
23141     UNLIMITED_CRYPTO=true
23142   else
23143     UNLIMITED_CRYPTO=false
23144   fi
23145 
23146 
23147   ###############################################################################
23148   #
23149   # Compress jars
23150   #
23151   COMPRESS_JARS=false
23152 
23153 
23154 
23155   # Setup default copyright year. Mostly overridden when building close to a new year.
23156 
23157 # Check whether --with-copyright-year was given.
23158 if test "${with_copyright_year+set}" = set; then :
23159   withval=$with_copyright_year;
23160 fi
23161 
23162   if test "x$with_copyright_year" = xyes; then
23163     as_fn_error $? "Copyright year must have a value" "$LINENO" 5
23164   elif test "x$with_copyright_year" != x; then
23165     COPYRIGHT_YEAR="$with_copyright_year"
23166   else
23167     COPYRIGHT_YEAR=`date +'%Y'`
23168   fi
23169 
23170 
23171 
23172   # Warn user that old version arguments are deprecated.
23173 
23174 
23175 # Check whether --with-milestone was given.
23176 if test "${with_milestone+set}" = set; then :
23177   withval=$with_milestone; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-milestone is deprecated and will be ignored." >&5
23178 $as_echo "$as_me: WARNING: Option --with-milestone is deprecated and will be ignored." >&2;}
23179 fi
23180 
23181 
23182 
23183 
23184 # Check whether --with-update-version was given.
23185 if test "${with_update_version+set}" = set; then :
23186   withval=$with_update_version; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-update-version is deprecated and will be ignored." >&5
23187 $as_echo "$as_me: WARNING: Option --with-update-version is deprecated and will be ignored." >&2;}
23188 fi
23189 
23190 
23191 
23192 
23193 # Check whether --with-user-release-suffix was given.
23194 if test "${with_user_release_suffix+set}" = set; then :
23195   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
23196 $as_echo "$as_me: WARNING: Option --with-user-release-suffix is deprecated and will be ignored." >&2;}
23197 fi
23198 
23199 
23200 
23201 
23202 # Check whether --with-build-number was given.
23203 if test "${with_build_number+set}" = set; then :
23204   withval=$with_build_number; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-build-number is deprecated and will be ignored." >&5
23205 $as_echo "$as_me: WARNING: Option --with-build-number is deprecated and will be ignored." >&2;}
23206 fi
23207 
23208 
23209 
23210   # Source the version numbers file
23211   . $AUTOCONF_DIR/version-numbers
23212 
23213   # Some non-version number information is set in that file
23214 
23215 
23216 
23217 
23218 
23219 
23220 
23221 
23222   # Override version from arguments
23223 
23224   # If --with-version-string is set, process it first. It is possible to
23225   # override parts with more specific flags, since these are processed later.
23226 
23227 # Check whether --with-version-string was given.
23228 if test "${with_version_string+set}" = set; then :
23229   withval=$with_version_string;
23230 fi
23231 
23232   if test "x$with_version_string" = xyes; then
23233     as_fn_error $? "--with-version-string must have a value" "$LINENO" 5
23234   elif test "x$with_version_string" != x; then
23235     # Additional [] needed to keep m4 from mangling shell constructs.
23236     if  [[ $with_version_string =~ ^([0-9]+)(\.([0-9]+))?(\.([0-9]+))?(\.([0-9]+))?(-([a-zA-Z]+))?((\+)([0-9]+)?(-([-a-zA-Z0-9.]+))?)?$ ]] ; then
23237       VERSION_MAJOR=${BASH_REMATCH[1]}
23238       VERSION_MINOR=${BASH_REMATCH[3]}
23239       VERSION_SECURITY=${BASH_REMATCH[5]}
23240       VERSION_PATCH=${BASH_REMATCH[7]}
23241       VERSION_PRE=${BASH_REMATCH[9]}
23242       version_plus_separator=${BASH_REMATCH[11]}
23243       VERSION_BUILD=${BASH_REMATCH[12]}
23244       VERSION_OPT=${BASH_REMATCH[14]}
23245       # Unspecified numerical fields are interpreted as 0.
23246       if test "x$VERSION_MINOR" = x; then
23247         VERSION_MINOR=0
23248       fi
23249       if test "x$VERSION_SECURITY" = x; then
23250         VERSION_SECURITY=0
23251       fi
23252       if test "x$VERSION_PATCH" = x; then
23253         VERSION_PATCH=0
23254       fi
23255       if test "x$version_plus_separator" != x \
23256           && test "x$VERSION_BUILD$VERSION_OPT" = x; then
23257         as_fn_error $? "Version string contains + but both 'BUILD' and 'OPT' are missing" "$LINENO" 5
23258       fi
23259       # Stop the version part process from setting default values.
23260       # We still allow them to explicitely override though.
23261       NO_DEFAULT_VERSION_PARTS=true
23262     else
23263       as_fn_error $? "--with-version-string fails to parse as a valid version string: $with_version_string" "$LINENO" 5
23264     fi
23265   fi
23266 
23267 
23268 # Check whether --with-version-pre was given.
23269 if test "${with_version_pre+set}" = set; then :
23270   withval=$with_version_pre; with_version_pre_present=true
23271 else
23272   with_version_pre_present=false
23273 fi
23274 
23275 
23276   if test "x$with_version_pre_present" = xtrue; then
23277     if test "x$with_version_pre" = xyes; then
23278       as_fn_error $? "--with-version-pre must have a value" "$LINENO" 5
23279     elif test "x$with_version_pre" = xno; then
23280       # Interpret --without-* as empty string instead of the literal "no"
23281       VERSION_PRE=
23282     else
23283       # Only [a-zA-Z] is allowed in the VERSION_PRE. Outer [ ] to quote m4.
23284        VERSION_PRE=`$ECHO "$with_version_pre" | $TR -c -d '[a-z][A-Z]'`
23285       if test "x$VERSION_PRE" != "x$with_version_pre"; then
23286         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: --with-version-pre value has been sanitized from '$with_version_pre' to '$VERSION_PRE'" >&5
23287 $as_echo "$as_me: WARNING: --with-version-pre value has been sanitized from '$with_version_pre' to '$VERSION_PRE'" >&2;}
23288       fi
23289     fi
23290   else
23291     if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
23292       # Default is to use "internal" as pre
23293       VERSION_PRE="internal"
23294     fi
23295   fi
23296 
23297 
23298 # Check whether --with-version-opt was given.
23299 if test "${with_version_opt+set}" = set; then :
23300   withval=$with_version_opt; with_version_opt_present=true
23301 else
23302   with_version_opt_present=false
23303 fi
23304 
23305 
23306   if test "x$with_version_opt_present" = xtrue; then
23307     if test "x$with_version_opt" = xyes; then
23308       as_fn_error $? "--with-version-opt must have a value" "$LINENO" 5
23309     elif test "x$with_version_opt" = xno; then
23310       # Interpret --without-* as empty string instead of the literal "no"
23311       VERSION_OPT=
23312     else
23313       # Only [-.a-zA-Z0-9] is allowed in the VERSION_OPT. Outer [ ] to quote m4.
23314        VERSION_OPT=`$ECHO "$with_version_opt" | $TR -c -d '[a-z][A-Z][0-9].-'`
23315       if test "x$VERSION_OPT" != "x$with_version_opt"; then
23316         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: --with-version-opt value has been sanitized from '$with_version_opt' to '$VERSION_OPT'" >&5
23317 $as_echo "$as_me: WARNING: --with-version-opt value has been sanitized from '$with_version_opt' to '$VERSION_OPT'" >&2;}
23318       fi
23319     fi
23320   else
23321     if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
23322       # Default is to calculate a string like this <timestamp>.<username>.<base dir name>
23323       timestamp=`$DATE '+%Y-%m-%d-%H%M%S'`
23324       # Outer [ ] to quote m4.
23325        username=`$ECHO "$USER" | $TR -d -c '[a-z][A-Z][0-9]'`
23326        basedirname=`$BASENAME "$TOPDIR" | $TR -d -c '[a-z][A-Z][0-9].-'`
23327       VERSION_OPT="$timestamp.$username.$basedirname"
23328     fi
23329   fi
23330 
23331 
23332 # Check whether --with-version-build was given.
23333 if test "${with_version_build+set}" = set; then :
23334   withval=$with_version_build; with_version_build_present=true
23335 else
23336   with_version_build_present=false
23337 fi
23338 
23339 
23340   if test "x$with_version_build_present" = xtrue; then
23341     if test "x$with_version_build" = xyes; then
23342       as_fn_error $? "--with-version-build must have a value" "$LINENO" 5
23343     elif test "x$with_version_build" = xno; then
23344       # Interpret --without-* as empty string instead of the literal "no"
23345       VERSION_BUILD=
23346     elif test "x$with_version_build" = x; then
23347       VERSION_BUILD=
23348     else
23349 
23350   # Additional [] needed to keep m4 from mangling shell constructs.
23351   if  ! [[ "$with_version_build" =~ ^0*([1-9][0-9]*)|(0)$ ]]  ; then
23352     as_fn_error $? "\"$with_version_build\" is not a valid numerical value for VERSION_BUILD" "$LINENO" 5
23353   fi
23354   # Extract the version number without leading zeros.
23355   cleaned_value=${BASH_REMATCH[1]}
23356   if test "x$cleaned_value" = x; then
23357     # Special case for zero
23358     cleaned_value=${BASH_REMATCH[2]}
23359   fi
23360 
23361   if test $cleaned_value -gt 255; then
23362     as_fn_error $? "VERSION_BUILD is given as $with_version_build. This is greater than 255 which is not allowed." "$LINENO" 5
23363   fi
23364   if test "x$cleaned_value" != "x$with_version_build"; then
23365     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Value for VERSION_BUILD has been sanitized from '$with_version_build' to '$cleaned_value'" >&5
23366 $as_echo "$as_me: WARNING: Value for VERSION_BUILD has been sanitized from '$with_version_build' to '$cleaned_value'" >&2;}
23367   fi
23368   VERSION_BUILD=$cleaned_value
23369 
23370     fi
23371   else
23372     if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
23373       # Default is to not have a build number.
23374       VERSION_BUILD=""
23375       # FIXME: Until all code can cope with an empty VERSION_BUILD, set it to 0.
23376       VERSION_BUILD=0
23377     fi
23378   fi
23379 
23380 
23381 # Check whether --with-version-major was given.
23382 if test "${with_version_major+set}" = set; then :
23383   withval=$with_version_major; with_version_major_present=true
23384 else
23385   with_version_major_present=false
23386 fi
23387 
23388 
23389   if test "x$with_version_major_present" = xtrue; then
23390     if test "x$with_version_major" = xyes; then
23391       as_fn_error $? "--with-version-major must have a value" "$LINENO" 5
23392     else
23393 
23394   # Additional [] needed to keep m4 from mangling shell constructs.
23395   if  ! [[ "$with_version_major" =~ ^0*([1-9][0-9]*)|(0)$ ]]  ; then
23396     as_fn_error $? "\"$with_version_major\" is not a valid numerical value for VERSION_MAJOR" "$LINENO" 5
23397   fi
23398   # Extract the version number without leading zeros.
23399   cleaned_value=${BASH_REMATCH[1]}
23400   if test "x$cleaned_value" = x; then
23401     # Special case for zero
23402     cleaned_value=${BASH_REMATCH[2]}
23403   fi
23404 
23405   if test $cleaned_value -gt 255; then
23406     as_fn_error $? "VERSION_MAJOR is given as $with_version_major. This is greater than 255 which is not allowed." "$LINENO" 5
23407   fi
23408   if test "x$cleaned_value" != "x$with_version_major"; then
23409     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Value for VERSION_MAJOR has been sanitized from '$with_version_major' to '$cleaned_value'" >&5
23410 $as_echo "$as_me: WARNING: Value for VERSION_MAJOR has been sanitized from '$with_version_major' to '$cleaned_value'" >&2;}
23411   fi
23412   VERSION_MAJOR=$cleaned_value
23413 
23414     fi
23415   else
23416     if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
23417       # Default is to get value from version-numbers
23418       VERSION_MAJOR="$DEFAULT_VERSION_MAJOR"
23419     fi
23420   fi
23421 
23422 
23423 # Check whether --with-version-minor was given.
23424 if test "${with_version_minor+set}" = set; then :
23425   withval=$with_version_minor; with_version_minor_present=true
23426 else
23427   with_version_minor_present=false
23428 fi
23429 
23430 
23431   if test "x$with_version_minor_present" = xtrue; then
23432     if test "x$with_version_minor" = xyes; then
23433       as_fn_error $? "--with-version-minor must have a value" "$LINENO" 5
23434     elif test "x$with_version_minor" = xno; then
23435       # Interpret --without-* as empty string (i.e. 0) instead of the literal "no"
23436       VERSION_MINOR=0
23437     elif test "x$with_version_minor" = x; then
23438       VERSION_MINOR=0
23439     else
23440 
23441   # Additional [] needed to keep m4 from mangling shell constructs.
23442   if  ! [[ "$with_version_minor" =~ ^0*([1-9][0-9]*)|(0)$ ]]  ; then
23443     as_fn_error $? "\"$with_version_minor\" is not a valid numerical value for VERSION_MINOR" "$LINENO" 5
23444   fi
23445   # Extract the version number without leading zeros.
23446   cleaned_value=${BASH_REMATCH[1]}
23447   if test "x$cleaned_value" = x; then
23448     # Special case for zero
23449     cleaned_value=${BASH_REMATCH[2]}
23450   fi
23451 
23452   if test $cleaned_value -gt 255; then
23453     as_fn_error $? "VERSION_MINOR is given as $with_version_minor. This is greater than 255 which is not allowed." "$LINENO" 5
23454   fi
23455   if test "x$cleaned_value" != "x$with_version_minor"; then
23456     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Value for VERSION_MINOR has been sanitized from '$with_version_minor' to '$cleaned_value'" >&5
23457 $as_echo "$as_me: WARNING: Value for VERSION_MINOR has been sanitized from '$with_version_minor' to '$cleaned_value'" >&2;}
23458   fi
23459   VERSION_MINOR=$cleaned_value
23460 
23461     fi
23462   else
23463     if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
23464       # Default is 0, if unspecified
23465       VERSION_MINOR=0
23466     fi
23467   fi
23468 
23469 
23470 # Check whether --with-version-security was given.
23471 if test "${with_version_security+set}" = set; then :
23472   withval=$with_version_security; with_version_security_present=true
23473 else
23474   with_version_security_present=false
23475 fi
23476 
23477 
23478   if test "x$with_version_security_present" = xtrue; then
23479     if test "x$with_version_security" = xyes; then
23480       as_fn_error $? "--with-version-security must have a value" "$LINENO" 5
23481     elif test "x$with_version_security" = xno; then
23482       # Interpret --without-* as empty string (i.e. 0) instead of the literal "no"
23483       VERSION_SECURITY=0
23484     elif test "x$with_version_security" = x; then
23485       VERSION_SECURITY=0
23486     else
23487 
23488   # Additional [] needed to keep m4 from mangling shell constructs.
23489   if  ! [[ "$with_version_security" =~ ^0*([1-9][0-9]*)|(0)$ ]]  ; then
23490     as_fn_error $? "\"$with_version_security\" is not a valid numerical value for VERSION_SECURITY" "$LINENO" 5
23491   fi
23492   # Extract the version number without leading zeros.
23493   cleaned_value=${BASH_REMATCH[1]}
23494   if test "x$cleaned_value" = x; then
23495     # Special case for zero
23496     cleaned_value=${BASH_REMATCH[2]}
23497   fi
23498 
23499   if test $cleaned_value -gt 255; then
23500     as_fn_error $? "VERSION_SECURITY is given as $with_version_security. This is greater than 255 which is not allowed." "$LINENO" 5
23501   fi
23502   if test "x$cleaned_value" != "x$with_version_security"; then
23503     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Value for VERSION_SECURITY has been sanitized from '$with_version_security' to '$cleaned_value'" >&5
23504 $as_echo "$as_me: WARNING: Value for VERSION_SECURITY has been sanitized from '$with_version_security' to '$cleaned_value'" >&2;}
23505   fi
23506   VERSION_SECURITY=$cleaned_value
23507 
23508     fi
23509   else
23510     if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
23511       # Default is 0, if unspecified
23512       VERSION_SECURITY=0
23513     fi
23514   fi
23515 
23516 
23517 # Check whether --with-version-patch was given.
23518 if test "${with_version_patch+set}" = set; then :
23519   withval=$with_version_patch; with_version_patch_present=true
23520 else
23521   with_version_patch_present=false
23522 fi
23523 
23524 
23525   if test "x$with_version_patch_present" = xtrue; then
23526     if test "x$with_version_patch" = xyes; then
23527       as_fn_error $? "--with-version-patch must have a value" "$LINENO" 5
23528     elif test "x$with_version_patch" = xno; then
23529       # Interpret --without-* as empty string (i.e. 0) instead of the literal "no"
23530       VERSION_PATCH=0
23531     elif test "x$with_version_patch" = x; then
23532       VERSION_PATCH=0
23533     else
23534 
23535   # Additional [] needed to keep m4 from mangling shell constructs.
23536   if  ! [[ "$with_version_patch" =~ ^0*([1-9][0-9]*)|(0)$ ]]  ; then
23537     as_fn_error $? "\"$with_version_patch\" is not a valid numerical value for VERSION_PATCH" "$LINENO" 5
23538   fi
23539   # Extract the version number without leading zeros.
23540   cleaned_value=${BASH_REMATCH[1]}
23541   if test "x$cleaned_value" = x; then
23542     # Special case for zero
23543     cleaned_value=${BASH_REMATCH[2]}
23544   fi
23545 
23546   if test $cleaned_value -gt 255; then
23547     as_fn_error $? "VERSION_PATCH is given as $with_version_patch. This is greater than 255 which is not allowed." "$LINENO" 5
23548   fi
23549   if test "x$cleaned_value" != "x$with_version_patch"; then
23550     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Value for VERSION_PATCH has been sanitized from '$with_version_patch' to '$cleaned_value'" >&5
23551 $as_echo "$as_me: WARNING: Value for VERSION_PATCH has been sanitized from '$with_version_patch' to '$cleaned_value'" >&2;}
23552   fi
23553   VERSION_PATCH=$cleaned_value
23554 
23555     fi
23556   else
23557     if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
23558       # Default is 0, if unspecified
23559       VERSION_PATCH=0
23560     fi
23561   fi
23562 
23563   # Calculate derived version properties
23564 
23565   # Set VERSION_IS_GA based on if VERSION_PRE has a value
23566   if test "x$VERSION_PRE" = x; then
23567     VERSION_IS_GA=true
23568   else
23569     VERSION_IS_GA=false
23570   fi
23571 
23572   # VERSION_NUMBER but always with exactly 4 positions, with 0 for empty positions.
23573   VERSION_NUMBER_FOUR_POSITIONS=$VERSION_MAJOR.$VERSION_MINOR.$VERSION_SECURITY.$VERSION_PATCH
23574 
23575   stripped_version_number=$VERSION_NUMBER_FOUR_POSITIONS
23576   # Strip trailing zeroes from stripped_version_number
23577   for i in 1 2 3 ; do stripped_version_number=${stripped_version_number%.0} ; done
23578   VERSION_NUMBER=$stripped_version_number
23579 
23580   # The complete version string, with additional build information
23581   if test "x$VERSION_BUILD$VERSION_OPT" = x; then
23582     VERSION_STRING=$VERSION_NUMBER${VERSION_PRE:+-$VERSION_PRE}
23583   else
23584     # If either build or opt is set, we need a + separator
23585     VERSION_STRING=$VERSION_NUMBER${VERSION_PRE:+-$VERSION_PRE}+$VERSION_BUILD${VERSION_OPT:+-$VERSION_OPT}
23586   fi
23587 
23588   # The short version string, just VERSION_NUMBER and PRE, if present.
23589   VERSION_SHORT=$VERSION_NUMBER${VERSION_PRE:+-$VERSION_PRE}
23590 
23591   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for version string" >&5
23592 $as_echo_n "checking for version string... " >&6; }
23593   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $VERSION_STRING" >&5
23594 $as_echo "$VERSION_STRING" >&6; }
23595 
23596 
23597 
23598 
23599 
23600 
23601 
23602 
23603 
23604 
23605 
23606 
23607 
23608 
23609 
23610 ###############################################################################
23611 #
23612 # Setup BootJDK, used to bootstrap the build.
23613 #
23614 ###############################################################################
23615 
23616 
23617   BOOT_JDK_FOUND=no
23618 
23619 # Check whether --with-boot-jdk was given.
23620 if test "${with_boot_jdk+set}" = set; then :
23621   withval=$with_boot_jdk;
23622 fi
23623 
23624 
23625   # We look for the Boot JDK through various means, going from more certain to
23626   # more of a guess-work. After each test, BOOT_JDK_FOUND is set to "yes" if
23627   # we detected something (if so, the path to the jdk is in BOOT_JDK). But we
23628   # must check if this is indeed valid; otherwise we'll continue looking.
23629 
23630   # Test: Is bootjdk explicitely set by command line arguments?
23631 
23632   if test "x$BOOT_JDK_FOUND" = xno; then
23633     # Now execute the test
23634 
23635   if test "x$with_boot_jdk" != x; then
23636     BOOT_JDK=$with_boot_jdk
23637     BOOT_JDK_FOUND=maybe
23638     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using configure arguments" >&5
23639 $as_echo "$as_me: Found potential Boot JDK using configure arguments" >&6;}
23640   fi
23641 
23642 
23643     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23644     if test "x$BOOT_JDK_FOUND" = xmaybe; then
23645       # Do we have a bin/java?
23646       if test ! -x "$BOOT_JDK/bin/java"; then
23647         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23648 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23649         BOOT_JDK_FOUND=no
23650       else
23651         # Do we have a bin/javac?
23652         if test ! -x "$BOOT_JDK/bin/javac"; then
23653           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23654 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23655           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23656 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23657           BOOT_JDK_FOUND=no
23658         else
23659           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23660           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23661 
23662           # Extra M4 quote needed to protect [] in grep expression.
23663           FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
23664           if test "x$FOUND_CORRECT_VERSION" = x; then
23665             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23666 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23667             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
23668 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
23669             BOOT_JDK_FOUND=no
23670           else
23671             # We're done! :-)
23672             BOOT_JDK_FOUND=yes
23673 
23674   # Only process if variable expands to non-empty
23675 
23676   if test "x$BOOT_JDK" != x; then
23677     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23678 
23679   # Input might be given as Windows format, start by converting to
23680   # unix format.
23681   path="$BOOT_JDK"
23682   new_path=`$CYGPATH -u "$path"`
23683 
23684   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23685   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23686   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23687   # "foo.exe" is OK but "foo" is an error.
23688   #
23689   # This test is therefore slightly more accurate than "test -f" to check for file precense.
23690   # It is also a way to make sure we got the proper file name for the real test later on.
23691   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23692   if test "x$test_shortpath" = x; then
23693     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23694 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23695     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23696   fi
23697 
23698   # Call helper function which possibly converts this using DOS-style short mode.
23699   # If so, the updated path is stored in $new_path.
23700 
23701   input_path="$new_path"
23702   # Check if we need to convert this using DOS-style short mode. If the path
23703   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23704   # take no chances and rewrite it.
23705   # Note: m4 eats our [], so we need to use [ and ] instead.
23706   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23707   if test "x$has_forbidden_chars" != x; then
23708     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23709     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23710     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23711     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23712       # Going to short mode and back again did indeed matter. Since short mode is
23713       # case insensitive, let's make it lowercase to improve readability.
23714       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23715       # Now convert it back to Unix-style (cygpath)
23716       input_path=`$CYGPATH -u "$shortmode_path"`
23717       new_path="$input_path"
23718     fi
23719   fi
23720 
23721   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23722   if test "x$test_cygdrive_prefix" = x; then
23723     # As a simple fix, exclude /usr/bin since it's not a real path.
23724     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23725       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23726       # a path prefixed by /cygdrive for fixpath to work.
23727       new_path="$CYGWIN_ROOT_PATH$input_path"
23728     fi
23729   fi
23730 
23731 
23732   if test "x$path" != "x$new_path"; then
23733     BOOT_JDK="$new_path"
23734     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23735 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23736   fi
23737 
23738     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23739 
23740   path="$BOOT_JDK"
23741   has_colon=`$ECHO $path | $GREP ^.:`
23742   new_path="$path"
23743   if test "x$has_colon" = x; then
23744     # Not in mixed or Windows style, start by that.
23745     new_path=`cmd //c echo $path`
23746   fi
23747 
23748 
23749   input_path="$new_path"
23750   # Check if we need to convert this using DOS-style short mode. If the path
23751   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23752   # take no chances and rewrite it.
23753   # Note: m4 eats our [], so we need to use [ and ] instead.
23754   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23755   if test "x$has_forbidden_chars" != x; then
23756     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23757     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23758   fi
23759 
23760 
23761   windows_path="$new_path"
23762   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23763     unix_path=`$CYGPATH -u "$windows_path"`
23764     new_path="$unix_path"
23765   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23766     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23767     new_path="$unix_path"
23768   fi
23769 
23770   if test "x$path" != "x$new_path"; then
23771     BOOT_JDK="$new_path"
23772     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23773 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23774   fi
23775 
23776   # Save the first 10 bytes of this path to the storage, so fixpath can work.
23777   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23778 
23779     else
23780       # We're on a unix platform. Hooray! :)
23781       path="$BOOT_JDK"
23782       has_space=`$ECHO "$path" | $GREP " "`
23783       if test "x$has_space" != x; then
23784         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23785 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23786         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23787       fi
23788 
23789       # Use eval to expand a potential ~
23790       eval path="$path"
23791       if test ! -f "$path" && test ! -d "$path"; then
23792         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23793       fi
23794 
23795       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23796     fi
23797   fi
23798 
23799             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23800 $as_echo_n "checking for Boot JDK... " >&6; }
23801             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23802 $as_echo "$BOOT_JDK" >&6; }
23803             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23804 $as_echo_n "checking Boot JDK version... " >&6; }
23805             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
23806             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23807 $as_echo "$BOOT_JDK_VERSION" >&6; }
23808           fi # end check jdk version
23809         fi # end check javac
23810       fi # end check java
23811     fi # end check boot jdk found
23812   fi
23813 
23814   if test "x$with_boot_jdk" != x && test "x$BOOT_JDK_FOUND" = xno; then
23815     # Having specified an argument which is incorrect will produce an instant failure;
23816     # we should not go on looking
23817     as_fn_error $? "The path given by --with-boot-jdk does not contain a valid Boot JDK" "$LINENO" 5
23818   fi
23819 
23820   # Test: On MacOS X, can we find a boot jdk using /usr/libexec/java_home?
23821 
23822   if test "x$BOOT_JDK_FOUND" = xno; then
23823     # Now execute the test
23824 
23825   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
23826     # First check at user selected default
23827 
23828   if test "x$BOOT_JDK_FOUND" = xno; then
23829     # Now execute the test
23830 
23831   if test -x /usr/libexec/java_home; then
23832     BOOT_JDK=`/usr/libexec/java_home `
23833     BOOT_JDK_FOUND=maybe
23834     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home " >&5
23835 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home " >&6;}
23836   fi
23837 
23838 
23839     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23840     if test "x$BOOT_JDK_FOUND" = xmaybe; then
23841       # Do we have a bin/java?
23842       if test ! -x "$BOOT_JDK/bin/java"; then
23843         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23844 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23845         BOOT_JDK_FOUND=no
23846       else
23847         # Do we have a bin/javac?
23848         if test ! -x "$BOOT_JDK/bin/javac"; then
23849           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23850 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23851           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23852 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23853           BOOT_JDK_FOUND=no
23854         else
23855           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23856           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23857 
23858           # Extra M4 quote needed to protect [] in grep expression.
23859           FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
23860           if test "x$FOUND_CORRECT_VERSION" = x; then
23861             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23862 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23863             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
23864 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
23865             BOOT_JDK_FOUND=no
23866           else
23867             # We're done! :-)
23868             BOOT_JDK_FOUND=yes
23869 
23870   # Only process if variable expands to non-empty
23871 
23872   if test "x$BOOT_JDK" != x; then
23873     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23874 
23875   # Input might be given as Windows format, start by converting to
23876   # unix format.
23877   path="$BOOT_JDK"
23878   new_path=`$CYGPATH -u "$path"`
23879 
23880   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23881   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23882   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23883   # "foo.exe" is OK but "foo" is an error.
23884   #
23885   # This test is therefore slightly more accurate than "test -f" to check for file precense.
23886   # It is also a way to make sure we got the proper file name for the real test later on.
23887   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23888   if test "x$test_shortpath" = x; then
23889     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23890 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23891     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23892   fi
23893 
23894   # Call helper function which possibly converts this using DOS-style short mode.
23895   # If so, the updated path is stored in $new_path.
23896 
23897   input_path="$new_path"
23898   # Check if we need to convert this using DOS-style short mode. If the path
23899   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23900   # take no chances and rewrite it.
23901   # Note: m4 eats our [], so we need to use [ and ] instead.
23902   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23903   if test "x$has_forbidden_chars" != x; then
23904     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23905     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23906     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23907     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23908       # Going to short mode and back again did indeed matter. Since short mode is
23909       # case insensitive, let's make it lowercase to improve readability.
23910       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23911       # Now convert it back to Unix-style (cygpath)
23912       input_path=`$CYGPATH -u "$shortmode_path"`
23913       new_path="$input_path"
23914     fi
23915   fi
23916 
23917   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23918   if test "x$test_cygdrive_prefix" = x; then
23919     # As a simple fix, exclude /usr/bin since it's not a real path.
23920     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23921       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23922       # a path prefixed by /cygdrive for fixpath to work.
23923       new_path="$CYGWIN_ROOT_PATH$input_path"
23924     fi
23925   fi
23926 
23927 
23928   if test "x$path" != "x$new_path"; then
23929     BOOT_JDK="$new_path"
23930     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23931 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23932   fi
23933 
23934     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23935 
23936   path="$BOOT_JDK"
23937   has_colon=`$ECHO $path | $GREP ^.:`
23938   new_path="$path"
23939   if test "x$has_colon" = x; then
23940     # Not in mixed or Windows style, start by that.
23941     new_path=`cmd //c echo $path`
23942   fi
23943 
23944 
23945   input_path="$new_path"
23946   # Check if we need to convert this using DOS-style short mode. If the path
23947   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23948   # take no chances and rewrite it.
23949   # Note: m4 eats our [], so we need to use [ and ] instead.
23950   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23951   if test "x$has_forbidden_chars" != x; then
23952     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23953     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23954   fi
23955 
23956 
23957   windows_path="$new_path"
23958   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23959     unix_path=`$CYGPATH -u "$windows_path"`
23960     new_path="$unix_path"
23961   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23962     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23963     new_path="$unix_path"
23964   fi
23965 
23966   if test "x$path" != "x$new_path"; then
23967     BOOT_JDK="$new_path"
23968     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23969 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23970   fi
23971 
23972   # Save the first 10 bytes of this path to the storage, so fixpath can work.
23973   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23974 
23975     else
23976       # We're on a unix platform. Hooray! :)
23977       path="$BOOT_JDK"
23978       has_space=`$ECHO "$path" | $GREP " "`
23979       if test "x$has_space" != x; then
23980         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23981 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23982         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23983       fi
23984 
23985       # Use eval to expand a potential ~
23986       eval path="$path"
23987       if test ! -f "$path" && test ! -d "$path"; then
23988         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23989       fi
23990 
23991       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23992     fi
23993   fi
23994 
23995             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23996 $as_echo_n "checking for Boot JDK... " >&6; }
23997             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23998 $as_echo "$BOOT_JDK" >&6; }
23999             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24000 $as_echo_n "checking Boot JDK version... " >&6; }
24001             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
24002             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24003 $as_echo "$BOOT_JDK_VERSION" >&6; }
24004           fi # end check jdk version
24005         fi # end check javac
24006       fi # end check java
24007     fi # end check boot jdk found
24008   fi
24009 
24010     # If that did not work out (e.g. too old), try explicit versions instead
24011 
24012   if test "x$BOOT_JDK_FOUND" = xno; then
24013     # Now execute the test
24014 
24015   if test -x /usr/libexec/java_home; then
24016     BOOT_JDK=`/usr/libexec/java_home -v 1.9`
24017     BOOT_JDK_FOUND=maybe
24018     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home -v 1.9" >&5
24019 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home -v 1.9" >&6;}
24020   fi
24021 
24022 
24023     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24024     if test "x$BOOT_JDK_FOUND" = xmaybe; then
24025       # Do we have a bin/java?
24026       if test ! -x "$BOOT_JDK/bin/java"; then
24027         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24028 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24029         BOOT_JDK_FOUND=no
24030       else
24031         # Do we have a bin/javac?
24032         if test ! -x "$BOOT_JDK/bin/javac"; then
24033           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24034 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24035           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24036 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24037           BOOT_JDK_FOUND=no
24038         else
24039           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24040           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24041 
24042           # Extra M4 quote needed to protect [] in grep expression.
24043           FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
24044           if test "x$FOUND_CORRECT_VERSION" = x; then
24045             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24046 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24047             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
24048 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
24049             BOOT_JDK_FOUND=no
24050           else
24051             # We're done! :-)
24052             BOOT_JDK_FOUND=yes
24053 
24054   # Only process if variable expands to non-empty
24055 
24056   if test "x$BOOT_JDK" != x; then
24057     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24058 
24059   # Input might be given as Windows format, start by converting to
24060   # unix format.
24061   path="$BOOT_JDK"
24062   new_path=`$CYGPATH -u "$path"`
24063 
24064   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24065   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24066   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24067   # "foo.exe" is OK but "foo" is an error.
24068   #
24069   # This test is therefore slightly more accurate than "test -f" to check for file precense.
24070   # It is also a way to make sure we got the proper file name for the real test later on.
24071   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24072   if test "x$test_shortpath" = x; then
24073     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24074 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24075     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24076   fi
24077 
24078   # Call helper function which possibly converts this using DOS-style short mode.
24079   # If so, the updated path is stored in $new_path.
24080 
24081   input_path="$new_path"
24082   # Check if we need to convert this using DOS-style short mode. If the path
24083   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24084   # take no chances and rewrite it.
24085   # Note: m4 eats our [], so we need to use [ and ] instead.
24086   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24087   if test "x$has_forbidden_chars" != x; then
24088     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24089     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24090     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24091     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24092       # Going to short mode and back again did indeed matter. Since short mode is
24093       # case insensitive, let's make it lowercase to improve readability.
24094       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24095       # Now convert it back to Unix-style (cygpath)
24096       input_path=`$CYGPATH -u "$shortmode_path"`
24097       new_path="$input_path"
24098     fi
24099   fi
24100 
24101   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24102   if test "x$test_cygdrive_prefix" = x; then
24103     # As a simple fix, exclude /usr/bin since it's not a real path.
24104     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24105       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24106       # a path prefixed by /cygdrive for fixpath to work.
24107       new_path="$CYGWIN_ROOT_PATH$input_path"
24108     fi
24109   fi
24110 
24111 
24112   if test "x$path" != "x$new_path"; then
24113     BOOT_JDK="$new_path"
24114     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24115 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24116   fi
24117 
24118     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24119 
24120   path="$BOOT_JDK"
24121   has_colon=`$ECHO $path | $GREP ^.:`
24122   new_path="$path"
24123   if test "x$has_colon" = x; then
24124     # Not in mixed or Windows style, start by that.
24125     new_path=`cmd //c echo $path`
24126   fi
24127 
24128 
24129   input_path="$new_path"
24130   # Check if we need to convert this using DOS-style short mode. If the path
24131   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24132   # take no chances and rewrite it.
24133   # Note: m4 eats our [], so we need to use [ and ] instead.
24134   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24135   if test "x$has_forbidden_chars" != x; then
24136     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24137     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24138   fi
24139 
24140 
24141   windows_path="$new_path"
24142   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24143     unix_path=`$CYGPATH -u "$windows_path"`
24144     new_path="$unix_path"
24145   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24146     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24147     new_path="$unix_path"
24148   fi
24149 
24150   if test "x$path" != "x$new_path"; then
24151     BOOT_JDK="$new_path"
24152     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24153 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24154   fi
24155 
24156   # Save the first 10 bytes of this path to the storage, so fixpath can work.
24157   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24158 
24159     else
24160       # We're on a unix platform. Hooray! :)
24161       path="$BOOT_JDK"
24162       has_space=`$ECHO "$path" | $GREP " "`
24163       if test "x$has_space" != x; then
24164         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24165 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24166         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24167       fi
24168 
24169       # Use eval to expand a potential ~
24170       eval path="$path"
24171       if test ! -f "$path" && test ! -d "$path"; then
24172         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24173       fi
24174 
24175       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24176     fi
24177   fi
24178 
24179             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24180 $as_echo_n "checking for Boot JDK... " >&6; }
24181             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24182 $as_echo "$BOOT_JDK" >&6; }
24183             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24184 $as_echo_n "checking Boot JDK version... " >&6; }
24185             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
24186             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24187 $as_echo "$BOOT_JDK_VERSION" >&6; }
24188           fi # end check jdk version
24189         fi # end check javac
24190       fi # end check java
24191     fi # end check boot jdk found
24192   fi
24193 
24194 
24195   if test "x$BOOT_JDK_FOUND" = xno; then
24196     # Now execute the test
24197 
24198   if test -x /usr/libexec/java_home; then
24199     BOOT_JDK=`/usr/libexec/java_home -v 1.8`
24200     BOOT_JDK_FOUND=maybe
24201     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home -v 1.8" >&5
24202 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home -v 1.8" >&6;}
24203   fi
24204 
24205 
24206     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24207     if test "x$BOOT_JDK_FOUND" = xmaybe; then
24208       # Do we have a bin/java?
24209       if test ! -x "$BOOT_JDK/bin/java"; then
24210         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24211 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24212         BOOT_JDK_FOUND=no
24213       else
24214         # Do we have a bin/javac?
24215         if test ! -x "$BOOT_JDK/bin/javac"; then
24216           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24217 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24218           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24219 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24220           BOOT_JDK_FOUND=no
24221         else
24222           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24223           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24224 
24225           # Extra M4 quote needed to protect [] in grep expression.
24226           FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
24227           if test "x$FOUND_CORRECT_VERSION" = x; then
24228             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24229 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24230             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
24231 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
24232             BOOT_JDK_FOUND=no
24233           else
24234             # We're done! :-)
24235             BOOT_JDK_FOUND=yes
24236 
24237   # Only process if variable expands to non-empty
24238 
24239   if test "x$BOOT_JDK" != x; then
24240     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24241 
24242   # Input might be given as Windows format, start by converting to
24243   # unix format.
24244   path="$BOOT_JDK"
24245   new_path=`$CYGPATH -u "$path"`
24246 
24247   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24248   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24249   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24250   # "foo.exe" is OK but "foo" is an error.
24251   #
24252   # This test is therefore slightly more accurate than "test -f" to check for file precense.
24253   # It is also a way to make sure we got the proper file name for the real test later on.
24254   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24255   if test "x$test_shortpath" = x; then
24256     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24257 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24258     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24259   fi
24260 
24261   # Call helper function which possibly converts this using DOS-style short mode.
24262   # If so, the updated path is stored in $new_path.
24263 
24264   input_path="$new_path"
24265   # Check if we need to convert this using DOS-style short mode. If the path
24266   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24267   # take no chances and rewrite it.
24268   # Note: m4 eats our [], so we need to use [ and ] instead.
24269   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24270   if test "x$has_forbidden_chars" != x; then
24271     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24272     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24273     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24274     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24275       # Going to short mode and back again did indeed matter. Since short mode is
24276       # case insensitive, let's make it lowercase to improve readability.
24277       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24278       # Now convert it back to Unix-style (cygpath)
24279       input_path=`$CYGPATH -u "$shortmode_path"`
24280       new_path="$input_path"
24281     fi
24282   fi
24283 
24284   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24285   if test "x$test_cygdrive_prefix" = x; then
24286     # As a simple fix, exclude /usr/bin since it's not a real path.
24287     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24288       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24289       # a path prefixed by /cygdrive for fixpath to work.
24290       new_path="$CYGWIN_ROOT_PATH$input_path"
24291     fi
24292   fi
24293 
24294 
24295   if test "x$path" != "x$new_path"; then
24296     BOOT_JDK="$new_path"
24297     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24298 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24299   fi
24300 
24301     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24302 
24303   path="$BOOT_JDK"
24304   has_colon=`$ECHO $path | $GREP ^.:`
24305   new_path="$path"
24306   if test "x$has_colon" = x; then
24307     # Not in mixed or Windows style, start by that.
24308     new_path=`cmd //c echo $path`
24309   fi
24310 
24311 
24312   input_path="$new_path"
24313   # Check if we need to convert this using DOS-style short mode. If the path
24314   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24315   # take no chances and rewrite it.
24316   # Note: m4 eats our [], so we need to use [ and ] instead.
24317   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24318   if test "x$has_forbidden_chars" != x; then
24319     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24320     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24321   fi
24322 
24323 
24324   windows_path="$new_path"
24325   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24326     unix_path=`$CYGPATH -u "$windows_path"`
24327     new_path="$unix_path"
24328   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24329     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24330     new_path="$unix_path"
24331   fi
24332 
24333   if test "x$path" != "x$new_path"; then
24334     BOOT_JDK="$new_path"
24335     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24336 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24337   fi
24338 
24339   # Save the first 10 bytes of this path to the storage, so fixpath can work.
24340   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24341 
24342     else
24343       # We're on a unix platform. Hooray! :)
24344       path="$BOOT_JDK"
24345       has_space=`$ECHO "$path" | $GREP " "`
24346       if test "x$has_space" != x; then
24347         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24348 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24349         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24350       fi
24351 
24352       # Use eval to expand a potential ~
24353       eval path="$path"
24354       if test ! -f "$path" && test ! -d "$path"; then
24355         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24356       fi
24357 
24358       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24359     fi
24360   fi
24361 
24362             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24363 $as_echo_n "checking for Boot JDK... " >&6; }
24364             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24365 $as_echo "$BOOT_JDK" >&6; }
24366             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24367 $as_echo_n "checking Boot JDK version... " >&6; }
24368             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
24369             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24370 $as_echo "$BOOT_JDK_VERSION" >&6; }
24371           fi # end check jdk version
24372         fi # end check javac
24373       fi # end check java
24374     fi # end check boot jdk found
24375   fi
24376 
24377 
24378   if test "x$BOOT_JDK_FOUND" = xno; then
24379     # Now execute the test
24380 
24381   if test -x /usr/libexec/java_home; then
24382     BOOT_JDK=`/usr/libexec/java_home -v 1.7`
24383     BOOT_JDK_FOUND=maybe
24384     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home -v 1.7" >&5
24385 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home -v 1.7" >&6;}
24386   fi
24387 
24388 
24389     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24390     if test "x$BOOT_JDK_FOUND" = xmaybe; then
24391       # Do we have a bin/java?
24392       if test ! -x "$BOOT_JDK/bin/java"; then
24393         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24394 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24395         BOOT_JDK_FOUND=no
24396       else
24397         # Do we have a bin/javac?
24398         if test ! -x "$BOOT_JDK/bin/javac"; then
24399           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24400 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24401           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24402 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24403           BOOT_JDK_FOUND=no
24404         else
24405           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24406           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24407 
24408           # Extra M4 quote needed to protect [] in grep expression.
24409           FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
24410           if test "x$FOUND_CORRECT_VERSION" = x; then
24411             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24412 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24413             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
24414 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
24415             BOOT_JDK_FOUND=no
24416           else
24417             # We're done! :-)
24418             BOOT_JDK_FOUND=yes
24419 
24420   # Only process if variable expands to non-empty
24421 
24422   if test "x$BOOT_JDK" != x; then
24423     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24424 
24425   # Input might be given as Windows format, start by converting to
24426   # unix format.
24427   path="$BOOT_JDK"
24428   new_path=`$CYGPATH -u "$path"`
24429 
24430   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24431   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24432   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24433   # "foo.exe" is OK but "foo" is an error.
24434   #
24435   # This test is therefore slightly more accurate than "test -f" to check for file precense.
24436   # It is also a way to make sure we got the proper file name for the real test later on.
24437   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24438   if test "x$test_shortpath" = x; then
24439     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24440 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24441     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24442   fi
24443 
24444   # Call helper function which possibly converts this using DOS-style short mode.
24445   # If so, the updated path is stored in $new_path.
24446 
24447   input_path="$new_path"
24448   # Check if we need to convert this using DOS-style short mode. If the path
24449   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24450   # take no chances and rewrite it.
24451   # Note: m4 eats our [], so we need to use [ and ] instead.
24452   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24453   if test "x$has_forbidden_chars" != x; then
24454     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24455     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24456     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24457     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24458       # Going to short mode and back again did indeed matter. Since short mode is
24459       # case insensitive, let's make it lowercase to improve readability.
24460       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24461       # Now convert it back to Unix-style (cygpath)
24462       input_path=`$CYGPATH -u "$shortmode_path"`
24463       new_path="$input_path"
24464     fi
24465   fi
24466 
24467   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24468   if test "x$test_cygdrive_prefix" = x; then
24469     # As a simple fix, exclude /usr/bin since it's not a real path.
24470     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24471       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24472       # a path prefixed by /cygdrive for fixpath to work.
24473       new_path="$CYGWIN_ROOT_PATH$input_path"
24474     fi
24475   fi
24476 
24477 
24478   if test "x$path" != "x$new_path"; then
24479     BOOT_JDK="$new_path"
24480     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24481 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24482   fi
24483 
24484     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24485 
24486   path="$BOOT_JDK"
24487   has_colon=`$ECHO $path | $GREP ^.:`
24488   new_path="$path"
24489   if test "x$has_colon" = x; then
24490     # Not in mixed or Windows style, start by that.
24491     new_path=`cmd //c echo $path`
24492   fi
24493 
24494 
24495   input_path="$new_path"
24496   # Check if we need to convert this using DOS-style short mode. If the path
24497   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24498   # take no chances and rewrite it.
24499   # Note: m4 eats our [], so we need to use [ and ] instead.
24500   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24501   if test "x$has_forbidden_chars" != x; then
24502     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24503     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24504   fi
24505 
24506 
24507   windows_path="$new_path"
24508   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24509     unix_path=`$CYGPATH -u "$windows_path"`
24510     new_path="$unix_path"
24511   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24512     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24513     new_path="$unix_path"
24514   fi
24515 
24516   if test "x$path" != "x$new_path"; then
24517     BOOT_JDK="$new_path"
24518     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24519 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24520   fi
24521 
24522   # Save the first 10 bytes of this path to the storage, so fixpath can work.
24523   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24524 
24525     else
24526       # We're on a unix platform. Hooray! :)
24527       path="$BOOT_JDK"
24528       has_space=`$ECHO "$path" | $GREP " "`
24529       if test "x$has_space" != x; then
24530         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24531 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24532         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24533       fi
24534 
24535       # Use eval to expand a potential ~
24536       eval path="$path"
24537       if test ! -f "$path" && test ! -d "$path"; then
24538         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24539       fi
24540 
24541       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24542     fi
24543   fi
24544 
24545             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24546 $as_echo_n "checking for Boot JDK... " >&6; }
24547             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24548 $as_echo "$BOOT_JDK" >&6; }
24549             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24550 $as_echo_n "checking Boot JDK version... " >&6; }
24551             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
24552             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24553 $as_echo "$BOOT_JDK_VERSION" >&6; }
24554           fi # end check jdk version
24555         fi # end check javac
24556       fi # end check java
24557     fi # end check boot jdk found
24558   fi
24559 
24560   fi
24561 
24562 
24563     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24564     if test "x$BOOT_JDK_FOUND" = xmaybe; then
24565       # Do we have a bin/java?
24566       if test ! -x "$BOOT_JDK/bin/java"; then
24567         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24568 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24569         BOOT_JDK_FOUND=no
24570       else
24571         # Do we have a bin/javac?
24572         if test ! -x "$BOOT_JDK/bin/javac"; then
24573           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24574 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24575           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24576 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24577           BOOT_JDK_FOUND=no
24578         else
24579           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24580           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24581 
24582           # Extra M4 quote needed to protect [] in grep expression.
24583           FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
24584           if test "x$FOUND_CORRECT_VERSION" = x; then
24585             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24586 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24587             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
24588 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
24589             BOOT_JDK_FOUND=no
24590           else
24591             # We're done! :-)
24592             BOOT_JDK_FOUND=yes
24593 
24594   # Only process if variable expands to non-empty
24595 
24596   if test "x$BOOT_JDK" != x; then
24597     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24598 
24599   # Input might be given as Windows format, start by converting to
24600   # unix format.
24601   path="$BOOT_JDK"
24602   new_path=`$CYGPATH -u "$path"`
24603 
24604   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24605   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24606   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24607   # "foo.exe" is OK but "foo" is an error.
24608   #
24609   # This test is therefore slightly more accurate than "test -f" to check for file precense.
24610   # It is also a way to make sure we got the proper file name for the real test later on.
24611   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24612   if test "x$test_shortpath" = x; then
24613     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24614 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24615     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24616   fi
24617 
24618   # Call helper function which possibly converts this using DOS-style short mode.
24619   # If so, the updated path is stored in $new_path.
24620 
24621   input_path="$new_path"
24622   # Check if we need to convert this using DOS-style short mode. If the path
24623   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24624   # take no chances and rewrite it.
24625   # Note: m4 eats our [], so we need to use [ and ] instead.
24626   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24627   if test "x$has_forbidden_chars" != x; then
24628     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24629     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24630     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24631     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24632       # Going to short mode and back again did indeed matter. Since short mode is
24633       # case insensitive, let's make it lowercase to improve readability.
24634       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24635       # Now convert it back to Unix-style (cygpath)
24636       input_path=`$CYGPATH -u "$shortmode_path"`
24637       new_path="$input_path"
24638     fi
24639   fi
24640 
24641   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24642   if test "x$test_cygdrive_prefix" = x; then
24643     # As a simple fix, exclude /usr/bin since it's not a real path.
24644     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24645       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24646       # a path prefixed by /cygdrive for fixpath to work.
24647       new_path="$CYGWIN_ROOT_PATH$input_path"
24648     fi
24649   fi
24650 
24651 
24652   if test "x$path" != "x$new_path"; then
24653     BOOT_JDK="$new_path"
24654     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24655 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24656   fi
24657 
24658     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24659 
24660   path="$BOOT_JDK"
24661   has_colon=`$ECHO $path | $GREP ^.:`
24662   new_path="$path"
24663   if test "x$has_colon" = x; then
24664     # Not in mixed or Windows style, start by that.
24665     new_path=`cmd //c echo $path`
24666   fi
24667 
24668 
24669   input_path="$new_path"
24670   # Check if we need to convert this using DOS-style short mode. If the path
24671   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24672   # take no chances and rewrite it.
24673   # Note: m4 eats our [], so we need to use [ and ] instead.
24674   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24675   if test "x$has_forbidden_chars" != x; then
24676     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24677     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24678   fi
24679 
24680 
24681   windows_path="$new_path"
24682   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24683     unix_path=`$CYGPATH -u "$windows_path"`
24684     new_path="$unix_path"
24685   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24686     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24687     new_path="$unix_path"
24688   fi
24689 
24690   if test "x$path" != "x$new_path"; then
24691     BOOT_JDK="$new_path"
24692     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24693 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24694   fi
24695 
24696   # Save the first 10 bytes of this path to the storage, so fixpath can work.
24697   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24698 
24699     else
24700       # We're on a unix platform. Hooray! :)
24701       path="$BOOT_JDK"
24702       has_space=`$ECHO "$path" | $GREP " "`
24703       if test "x$has_space" != x; then
24704         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24705 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24706         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24707       fi
24708 
24709       # Use eval to expand a potential ~
24710       eval path="$path"
24711       if test ! -f "$path" && test ! -d "$path"; then
24712         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24713       fi
24714 
24715       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24716     fi
24717   fi
24718 
24719             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24720 $as_echo_n "checking for Boot JDK... " >&6; }
24721             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24722 $as_echo "$BOOT_JDK" >&6; }
24723             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24724 $as_echo_n "checking Boot JDK version... " >&6; }
24725             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
24726             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24727 $as_echo "$BOOT_JDK_VERSION" >&6; }
24728           fi # end check jdk version
24729         fi # end check javac
24730       fi # end check java
24731     fi # end check boot jdk found
24732   fi
24733 
24734 
24735   # Test: Is $JAVA_HOME set?
24736 
24737   if test "x$BOOT_JDK_FOUND" = xno; then
24738     # Now execute the test
24739 
24740   if test "x$JAVA_HOME" != x; then
24741     JAVA_HOME_PROCESSED="$JAVA_HOME"
24742 
24743   # Only process if variable expands to non-empty
24744 
24745   if test "x$JAVA_HOME_PROCESSED" != x; then
24746     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24747 
24748   # Input might be given as Windows format, start by converting to
24749   # unix format.
24750   path="$JAVA_HOME_PROCESSED"
24751   new_path=`$CYGPATH -u "$path"`
24752 
24753   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24754   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24755   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24756   # "foo.exe" is OK but "foo" is an error.
24757   #
24758   # This test is therefore slightly more accurate than "test -f" to check for file precense.
24759   # It is also a way to make sure we got the proper file name for the real test later on.
24760   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24761   if test "x$test_shortpath" = x; then
24762     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&5
24763 $as_echo "$as_me: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&6;}
24764     as_fn_error $? "Cannot locate the the path of JAVA_HOME_PROCESSED" "$LINENO" 5
24765   fi
24766 
24767   # Call helper function which possibly converts this using DOS-style short mode.
24768   # If so, the updated path is stored in $new_path.
24769 
24770   input_path="$new_path"
24771   # Check if we need to convert this using DOS-style short mode. If the path
24772   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24773   # take no chances and rewrite it.
24774   # Note: m4 eats our [], so we need to use [ and ] instead.
24775   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24776   if test "x$has_forbidden_chars" != x; then
24777     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24778     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24779     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24780     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24781       # Going to short mode and back again did indeed matter. Since short mode is
24782       # case insensitive, let's make it lowercase to improve readability.
24783       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24784       # Now convert it back to Unix-style (cygpath)
24785       input_path=`$CYGPATH -u "$shortmode_path"`
24786       new_path="$input_path"
24787     fi
24788   fi
24789 
24790   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24791   if test "x$test_cygdrive_prefix" = x; then
24792     # As a simple fix, exclude /usr/bin since it's not a real path.
24793     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24794       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24795       # a path prefixed by /cygdrive for fixpath to work.
24796       new_path="$CYGWIN_ROOT_PATH$input_path"
24797     fi
24798   fi
24799 
24800 
24801   if test "x$path" != "x$new_path"; then
24802     JAVA_HOME_PROCESSED="$new_path"
24803     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&5
24804 $as_echo "$as_me: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&6;}
24805   fi
24806 
24807     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24808 
24809   path="$JAVA_HOME_PROCESSED"
24810   has_colon=`$ECHO $path | $GREP ^.:`
24811   new_path="$path"
24812   if test "x$has_colon" = x; then
24813     # Not in mixed or Windows style, start by that.
24814     new_path=`cmd //c echo $path`
24815   fi
24816 
24817 
24818   input_path="$new_path"
24819   # Check if we need to convert this using DOS-style short mode. If the path
24820   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24821   # take no chances and rewrite it.
24822   # Note: m4 eats our [], so we need to use [ and ] instead.
24823   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24824   if test "x$has_forbidden_chars" != x; then
24825     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24826     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24827   fi
24828 
24829 
24830   windows_path="$new_path"
24831   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24832     unix_path=`$CYGPATH -u "$windows_path"`
24833     new_path="$unix_path"
24834   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24835     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24836     new_path="$unix_path"
24837   fi
24838 
24839   if test "x$path" != "x$new_path"; then
24840     JAVA_HOME_PROCESSED="$new_path"
24841     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&5
24842 $as_echo "$as_me: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&6;}
24843   fi
24844 
24845   # Save the first 10 bytes of this path to the storage, so fixpath can work.
24846   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24847 
24848     else
24849       # We're on a unix platform. Hooray! :)
24850       path="$JAVA_HOME_PROCESSED"
24851       has_space=`$ECHO "$path" | $GREP " "`
24852       if test "x$has_space" != x; then
24853         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&5
24854 $as_echo "$as_me: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&6;}
24855         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24856       fi
24857 
24858       # Use eval to expand a potential ~
24859       eval path="$path"
24860       if test ! -f "$path" && test ! -d "$path"; then
24861         as_fn_error $? "The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is not found." "$LINENO" 5
24862       fi
24863 
24864       JAVA_HOME_PROCESSED="`cd "$path"; $THEPWDCMD -L`"
24865     fi
24866   fi
24867 
24868     if test ! -d "$JAVA_HOME_PROCESSED"; then
24869       { $as_echo "$as_me:${as_lineno-$LINENO}: Your JAVA_HOME points to a non-existing directory!" >&5
24870 $as_echo "$as_me: Your JAVA_HOME points to a non-existing directory!" >&6;}
24871     else
24872       # Aha, the user has set a JAVA_HOME
24873       # let us use that as the Boot JDK.
24874       BOOT_JDK="$JAVA_HOME_PROCESSED"
24875       BOOT_JDK_FOUND=maybe
24876       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using JAVA_HOME" >&5
24877 $as_echo "$as_me: Found potential Boot JDK using JAVA_HOME" >&6;}
24878     fi
24879   fi
24880 
24881 
24882     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24883     if test "x$BOOT_JDK_FOUND" = xmaybe; then
24884       # Do we have a bin/java?
24885       if test ! -x "$BOOT_JDK/bin/java"; then
24886         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24887 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24888         BOOT_JDK_FOUND=no
24889       else
24890         # Do we have a bin/javac?
24891         if test ! -x "$BOOT_JDK/bin/javac"; then
24892           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24893 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24894           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24895 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24896           BOOT_JDK_FOUND=no
24897         else
24898           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24899           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24900 
24901           # Extra M4 quote needed to protect [] in grep expression.
24902           FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
24903           if test "x$FOUND_CORRECT_VERSION" = x; then
24904             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24905 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24906             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
24907 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
24908             BOOT_JDK_FOUND=no
24909           else
24910             # We're done! :-)
24911             BOOT_JDK_FOUND=yes
24912 
24913   # Only process if variable expands to non-empty
24914 
24915   if test "x$BOOT_JDK" != x; then
24916     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24917 
24918   # Input might be given as Windows format, start by converting to
24919   # unix format.
24920   path="$BOOT_JDK"
24921   new_path=`$CYGPATH -u "$path"`
24922 
24923   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24924   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24925   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24926   # "foo.exe" is OK but "foo" is an error.
24927   #
24928   # This test is therefore slightly more accurate than "test -f" to check for file precense.
24929   # It is also a way to make sure we got the proper file name for the real test later on.
24930   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24931   if test "x$test_shortpath" = x; then
24932     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24933 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24934     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24935   fi
24936 
24937   # Call helper function which possibly converts this using DOS-style short mode.
24938   # If so, the updated path is stored in $new_path.
24939 
24940   input_path="$new_path"
24941   # Check if we need to convert this using DOS-style short mode. If the path
24942   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24943   # take no chances and rewrite it.
24944   # Note: m4 eats our [], so we need to use [ and ] instead.
24945   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24946   if test "x$has_forbidden_chars" != x; then
24947     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24948     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24949     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24950     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24951       # Going to short mode and back again did indeed matter. Since short mode is
24952       # case insensitive, let's make it lowercase to improve readability.
24953       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24954       # Now convert it back to Unix-style (cygpath)
24955       input_path=`$CYGPATH -u "$shortmode_path"`
24956       new_path="$input_path"
24957     fi
24958   fi
24959 
24960   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24961   if test "x$test_cygdrive_prefix" = x; then
24962     # As a simple fix, exclude /usr/bin since it's not a real path.
24963     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24964       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24965       # a path prefixed by /cygdrive for fixpath to work.
24966       new_path="$CYGWIN_ROOT_PATH$input_path"
24967     fi
24968   fi
24969 
24970 
24971   if test "x$path" != "x$new_path"; then
24972     BOOT_JDK="$new_path"
24973     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24974 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24975   fi
24976 
24977     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24978 
24979   path="$BOOT_JDK"
24980   has_colon=`$ECHO $path | $GREP ^.:`
24981   new_path="$path"
24982   if test "x$has_colon" = x; then
24983     # Not in mixed or Windows style, start by that.
24984     new_path=`cmd //c echo $path`
24985   fi
24986 
24987 
24988   input_path="$new_path"
24989   # Check if we need to convert this using DOS-style short mode. If the path
24990   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24991   # take no chances and rewrite it.
24992   # Note: m4 eats our [], so we need to use [ and ] instead.
24993   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24994   if test "x$has_forbidden_chars" != x; then
24995     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24996     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24997   fi
24998 
24999 
25000   windows_path="$new_path"
25001   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
25002     unix_path=`$CYGPATH -u "$windows_path"`
25003     new_path="$unix_path"
25004   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
25005     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
25006     new_path="$unix_path"
25007   fi
25008 
25009   if test "x$path" != "x$new_path"; then
25010     BOOT_JDK="$new_path"
25011     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
25012 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
25013   fi
25014 
25015   # Save the first 10 bytes of this path to the storage, so fixpath can work.
25016   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
25017 
25018     else
25019       # We're on a unix platform. Hooray! :)
25020       path="$BOOT_JDK"
25021       has_space=`$ECHO "$path" | $GREP " "`
25022       if test "x$has_space" != x; then
25023         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
25024 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
25025         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
25026       fi
25027 
25028       # Use eval to expand a potential ~
25029       eval path="$path"
25030       if test ! -f "$path" && test ! -d "$path"; then
25031         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
25032       fi
25033 
25034       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
25035     fi
25036   fi
25037 
25038             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
25039 $as_echo_n "checking for Boot JDK... " >&6; }
25040             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
25041 $as_echo "$BOOT_JDK" >&6; }
25042             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
25043 $as_echo_n "checking Boot JDK version... " >&6; }
25044             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
25045             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
25046 $as_echo "$BOOT_JDK_VERSION" >&6; }
25047           fi # end check jdk version
25048         fi # end check javac
25049       fi # end check java
25050     fi # end check boot jdk found
25051   fi
25052 
25053 
25054   # Test: Is there a java or javac in the PATH, which is a symlink to the JDK?
25055 
25056   if test "x$BOOT_JDK_FOUND" = xno; then
25057     # Now execute the test
25058 
25059   # Extract the first word of "javac", so it can be a program name with args.
25060 set dummy javac; ac_word=$2
25061 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
25062 $as_echo_n "checking for $ac_word... " >&6; }
25063 if ${ac_cv_path_JAVAC_CHECK+:} false; then :
25064   $as_echo_n "(cached) " >&6
25065 else
25066   case $JAVAC_CHECK in
25067   [\\/]* | ?:[\\/]*)
25068   ac_cv_path_JAVAC_CHECK="$JAVAC_CHECK" # Let the user override the test with a path.
25069   ;;
25070   *)
25071   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
25072 for as_dir in $PATH
25073 do
25074   IFS=$as_save_IFS
25075   test -z "$as_dir" && as_dir=.
25076     for ac_exec_ext in '' $ac_executable_extensions; do
25077   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
25078     ac_cv_path_JAVAC_CHECK="$as_dir/$ac_word$ac_exec_ext"
25079     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
25080     break 2
25081   fi
25082 done
25083   done
25084 IFS=$as_save_IFS
25085 
25086   ;;
25087 esac
25088 fi
25089 JAVAC_CHECK=$ac_cv_path_JAVAC_CHECK
25090 if test -n "$JAVAC_CHECK"; then
25091   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAVAC_CHECK" >&5
25092 $as_echo "$JAVAC_CHECK" >&6; }
25093 else
25094   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
25095 $as_echo "no" >&6; }
25096 fi
25097 
25098 
25099   # Extract the first word of "java", so it can be a program name with args.
25100 set dummy java; ac_word=$2
25101 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
25102 $as_echo_n "checking for $ac_word... " >&6; }
25103 if ${ac_cv_path_JAVA_CHECK+:} false; then :
25104   $as_echo_n "(cached) " >&6
25105 else
25106   case $JAVA_CHECK in
25107   [\\/]* | ?:[\\/]*)
25108   ac_cv_path_JAVA_CHECK="$JAVA_CHECK" # Let the user override the test with a path.
25109   ;;
25110   *)
25111   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
25112 for as_dir in $PATH
25113 do
25114   IFS=$as_save_IFS
25115   test -z "$as_dir" && as_dir=.
25116     for ac_exec_ext in '' $a